JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>serializationShape;
/*
/**********************************************************
/* Configuration for creating value instance
/**********************************************************
*/
/**
* Object that handles details of constructing initial
* bean value (to which bind data to), unless instance
* is passed (via updateValue())
*/
protected final ValueInstantiator _valueInstantiator;
/**
* Deserializer that is used iff delegate-based creator is
* to be used for deserializing from JSON Object.
*/
protected JsonDeserializer<Object> _delegateDeserializer;
/**
* Deserializer that is used iff array-delegate-based creator
* is to be used for deserializing from JSON Object.
*/
protected JsonDeserializer<Object> _arrayDelegateDeserializer;
/**
* If the bean needs to be instantiated using constructor
* or factory method
* that takes one or more named properties as argument(s),
* this creator is used for instantiation.
* This value gets resolved during general resolution.
*/
protected PropertyBasedCreator _propertyBasedCreator;
/**
* Flag that is set to mark "non-standard" cases; where either
* we use one of non-default creators, or there are unwrapped
* values to consider.
*/
protected boolean _nonStandardCreation;
/**
* Flag that indicates that no "special features" whatsoever
* are enabled, so the simplest processing is possible.
*/
protected boolean _vanillaProcessing;
/*
/**********************************************************
/* Property information, setters
/**********************************************************
*/
/**
* Mapping of property names to properties, built when all properties
* to use have been successfully resolved.
*/
final protected BeanPropertyMap _beanProperties;
/**
* List of {@link ValueInjector}s, if any injectable values are
* expected by the bean; otherwise null.
* This includes injectors used for injecting values via setters
* and fields, but not ones passed through constructor parameters.
*/
final protected ValueInjector[] _injectables;
/**
* Fallback setter used for handling any properties that are not
* mapped to regular setters. If setter is not null, it will be
* called once for each such property.
*/
protected SettableAnyProperty _anySetter;
/**
* In addition to properties that are set, we will also keep
* track of recognized but ignorable properties: these will
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> * be skipped without errors or warnings.
*/
final protected Set<String> _ignorableProps;
/**
* Flag that can be set to ignore and skip unknown properties.
* If set, will not throw an exception for unknown properties.
*/
final protected boolean _ignoreAllUnknown;
/**
* Flag that indicates that some aspect of deserialization depends
* on active view used (if any)
*/
final protected boolean _needViewProcesing;
/**
* We may also have one or more back reference fields (usually
* zero or one).
*/
final protected Map<String, SettableBeanProperty> _backRefs;
/*
/**********************************************************
/* Related handlers
/**********************************************************
*/
/**
* Lazily constructed map used to contain deserializers needed
* for polymorphic subtypes.
* Note that this is <b>only needed</b> for polymorphic types,
* that is, when the actual type is not statically known.
* For other types this remains null.
*/
protected transient HashMap<ClassKey, JsonDeserializer<Object>> _subDeserializers;
/**
* If one of properties has "unwrapped" value, we need separate
* helper object
*/
protected UnwrappedPropertyHandler _unwrappedPropertyHandler;
/**
* Handler that we need iff any of properties uses external
* type id.
*/
protected ExternalTypeHandler _externalTypeIdHandler;
/**
* If an Object Id is to be used for value handled by this
* deserializer, this reader is used for handling.
*/
protected final ObjectIdReader _objectIdReader;
/*
/**********************************************************
/* Life-cycle, construction, initialization
/**********************************************************
*/
/**
* Constructor used when initially building a deserializer
* instance, given a {@link BeanDeserializerBuilder} that
* contains configuration.
*/
protected BeanDeserializerBase(BeanDeserializerBuilder builder,
BeanDescription beanDesc,
BeanPropertyMap properties, Map<String, SettableBeanProperty> backRefs,
Set<String> ignorableProps, boolean ignoreAllUnknown,
boolean hasViews)
{
super(beanDesc.getType());
AnnotatedClass ac = beanDesc.getClassInfo();
_classAnnotations = ac.getAnnotations();
_beanType = beanDesc.getType();
_valueInstantiator = builder.getValueInstantiator
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>valueInstantiator;
_delegateDeserializer = src._delegateDeserializer;
_propertyBasedCreator = src._propertyBasedCreator;
_beanProperties = beanProps;
_backRefs = src._backRefs;
_ignorableProps = src._ignorableProps;
_ignoreAllUnknown = src._ignoreAllUnknown;
_anySetter = src._anySetter;
_injectables = src._injectables;
_objectIdReader = src._objectIdReader;
_nonStandardCreation = src._nonStandardCreation;
_unwrappedPropertyHandler = src._unwrappedPropertyHandler;
_needViewProcesing = src._needViewProcesing;
_serializationShape = src._serializationShape;
_vanillaProcessing = src._vanillaProcessing;
}
@Override
public abstract JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper);
public abstract BeanDeserializerBase withObjectIdReader(ObjectIdReader oir);
public abstract BeanDeserializerBase withIgnorableProperties(Set<String> ignorableProps);
/**
* Mutant factory method that custom sub-classes must override; not left as
* abstract to prevent more drastic backwards compatibility problems.
*
* @since 2.8
*/
public BeanDeserializerBase withBeanProperties(BeanPropertyMap props) {
throw new UnsupportedOperationException("Class "+getClass().getName()
+" does not override `withBeanProperties()`, needs to");
}
/**
* Fluent factory for creating a variant that can handle
* POJO output as a JSON Array. Implementations may ignore this request
* if no such input is possible.
*
* @since 2.1
*/
protected abstract BeanDeserializerBase asArrayDeserializer();
/*
/**********************************************************
/* Validation, post-processing
/**********************************************************
*/
/**
* Method called to finalize setup of this deserializer,
* after deserializer itself has been registered.
* This is needed to handle recursive and transitive dependencies.
*/
@Override
public void resolve(DeserializationContext ctxt)
throws JsonMappingException
{
ExternalTypeHandler.Builder extTypes = null;
// if ValueInstantiator can use "creator" approach, need to resolve it here...
SettableBeanProperty[] creatorProps;
if (_valueInstantiator.canCreateFromObjectWith()) {
creatorProps = _valueInstantiator.getFromObjectArguments(ctxt.getConfig());
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
// 21-Jun-2015, tatu: This resolution was duplicated later on and seems like
// it really should be only done at a later point. So commented out in 2.8.
// However, just in case there was a reason for it, leaving commented out
// here instead of immediately removing.
/*
// also: need to try to resolve 'external' type ids...
for (SettableBeanProperty prop : creatorProps) {
if (prop.hasValueTypeDeserializer()) {
TypeDeserializer typeDeser = prop.getValueTypeDeserializer();
if (typeDeser.getTypeInclusion() == JsonTypeInfo.As.EXTERNAL_PROPERTY) {
if (extTypes == null) {
extTypes = new ExternalTypeHandler.Builder();
}
extTypes.addExternal(prop, typeDeser);
}
}
}
*/
} else {
creatorProps = null;
}
UnwrappedPropertyHandler unwrapped = null;
for (SettableBeanProperty origProp : _beanProperties) {
SettableBeanProperty prop = origProp;
// May already have deserializer from annotations, if so, skip:
if (!prop.hasValueDeserializer()) {
// [databind#125]: allow use of converters
JsonDeserializer<?> deser = findConvertingDeserializer(ctxt, prop);
if (deser == null) {
deser = findDeserializer(ctxt, prop.getType(), prop);
}
prop = prop.withValueDeserializer(deser);
} else { // may need contextual version
JsonDeserializer<Object> deser = prop.getValueDeserializer();
/* Important! This is the only place where actually handle "primary"
* property deserializers -- call is different from other places.
*/
JsonDeserializer<?> cd = ctxt.handlePrimaryContextualization(deser, prop,
prop.getType());
if (cd != deser) {
prop = prop.withValueDeserializer(cd);
}
}
// Need to link managed references with matching back references
prop = _resolveManagedReferenceProperty(ctxt, prop);
// [databind#351]: need to wrap properties that require object id resolution.
if (!(prop instanceof ManagedReferenceProperty)) {
prop = _resolvedObjectIdProperty(ctxt, prop);
}
// Support unwrapped values (via @JsonUn
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
}
// may need to disable vanilla processing, if unwrapped handling was enabled...
_vanillaProcessing = _vanillaProcessing && !_nonStandardCreation;
}
private JsonDeserializer<Object> _findDelegateDeserializer(DeserializationContext ctxt, JavaType delegateType,
AnnotatedWithParams delegateCreator) throws JsonMappingException {
// Need to create a temporary property to allow contextual deserializers:
BeanProperty.Std property = new BeanProperty.Std(TEMP_PROPERTY_NAME,
delegateType, null, _classAnnotations, delegateCreator,
PropertyMetadata.STD_OPTIONAL);
TypeDeserializer td = delegateType.getTypeHandler();
if (td == null) {
td = ctxt.getConfig().findTypeDeserializer(delegateType);
}
JsonDeserializer<Object> dd = findDeserializer(ctxt, delegateType, property);
if (td != null) {
td = td.forProperty(property);
return new TypeWrappedDeserializer(td, dd);
}
return dd;
}
/**
* Helper method that can be used to see if specified property is annotated
* to indicate use of a converter for property value (in case of container types,
* it is container type itself, not key or content type).
*
* @since 2.2
*/
protected JsonDeserializer<Object> findConvertingDeserializer(DeserializationContext ctxt,
SettableBeanProperty prop)
throws JsonMappingException
{
final AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
if (intr != null) {
Object convDef = intr.findDeserializationConverter(prop.getMember());
if (convDef != null) {
Converter<Object,Object> conv = ctxt.converterInstance(prop.getMember(), convDef);
JavaType delegateType = conv.getInputType(ctxt.getTypeFactory());
JsonDeserializer<?> ser = ctxt.findContextualValueDeserializer(delegateType, prop);
return new StdDelegatingDeserializer<Object>(conv, delegateType, ser);
}
}
return null;
}
/**
* Although most of post-processing is done in resolve(), we only get
* access to referring property's annotations here; and this is needed
* to support per-property ObjectIds.
* We will also consider Shape transformations (read from Array) at this
* point, since it may come from either Class definition or property.
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
*/
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
ObjectIdReader oir = _objectIdReader;
// First: may have an override for Object Id:
final AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
final AnnotatedMember accessor = (property == null || intr == null)
? null : property.getMember();
if (accessor != null && intr != null) {
ObjectIdInfo objectIdInfo = intr.findObjectIdInfo(accessor);
if (objectIdInfo != null) { // some code duplication here as well (from BeanDeserializerFactory)
// 2.1: allow modifications by "id ref" annotations as well:
objectIdInfo = intr.findObjectReferenceInfo(accessor, objectIdInfo);
Class<?> implClass = objectIdInfo.getGeneratorType();
// Property-based generator is trickier
JavaType idType;
SettableBeanProperty idProp;
ObjectIdGenerator<?> idGen;
ObjectIdResolver resolver = ctxt.objectIdResolverInstance(accessor, objectIdInfo);
if (implClass == ObjectIdGenerators.PropertyGenerator.class) {
PropertyName propName = objectIdInfo.getPropertyName();
idProp = findProperty(propName);
if (idProp == null) {
throw new IllegalArgumentException("Invalid Object Id definition for "
+handledType().getName()+": can not find property with name '"+propName+"'");
}
idType = idProp.getType();
idGen = new PropertyBasedObjectIdGenerator(objectIdInfo.getScope());
} else { // other types need to be simpler
JavaType type = ctxt.constructType(implClass);
idType = ctxt.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0];
idProp = null;
idGen = ctxt.objectIdGeneratorInstance(accessor, objectIdInfo);
}
JsonDeserializer<?> deser = ctxt.findRootValueDeserializer(idType);
oir = ObjectIdReader.construct(idType, objectIdInfo.getPropertyName(),
idGen, deser, idProp, resolver);
}
}
// either way, need to resolve serializer:
BeanDeserializerBase contextual = this;
if (oir != null && oir != _objectIdReader) {
contextual = contextual.withObjectIdReader
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>(oir);
}
// And possibly add more properties to ignore
if (accessor != null) {
JsonIgnoreProperties.Value ignorals = intr.findPropertyIgnorals(accessor);
if (ignorals != null) {
Set<String> ignored = ignorals.findIgnoredForDeserialization();
if (!ignored.isEmpty()) {
Set<String> prev = contextual._ignorableProps;
if ((prev != null) && !prev.isEmpty()) {
ignored = new HashSet<String>(ignored);
ignored.addAll(prev);
}
contextual = contextual.withIgnorableProperties(ignored);
}
}
}
// One more thing: are we asked to serialize POJO as array?
JsonFormat.Value format = findFormatOverrides(ctxt, property, handledType());
JsonFormat.Shape shape = null;
if (format != null) {
if (format.hasShape()) {
shape = format.getShape();
}
// 16-May-2016, tatu: How about per-property case-insensitivity?
Boolean B = format.getFeature(JsonFormat.Feature.ACCEPT_CASE_INSENSITIVE_PROPERTIES);
if (B != null) {
// !!! TODO
BeanPropertyMap propsOrig = _beanProperties;
BeanPropertyMap props = propsOrig.withCaseInsensitivity(B.booleanValue());
if (props != propsOrig) {
contextual = contextual.withBeanProperties(props);
}
}
}
if (shape == null) {
shape = _serializationShape;
}
if (shape == JsonFormat.Shape.ARRAY) {
contextual = contextual.asArrayDeserializer();
}
return contextual;
}
/**
* Helper method called to see if given property is part of 'managed' property
* pair (managed + back reference), and if so, handle resolution details.
*/
protected SettableBeanProperty _resolveManagedReferenceProperty(DeserializationContext ctxt,
SettableBeanProperty prop)
{
String refName = prop.getManagedReferenceName();
if (refName == null) {
return prop;
}
JsonDeserializer<?> valueDeser = prop.getValueDeserializer();
SettableBeanProperty backProp = valueDeser.findBackReference(refName);
if (
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>backProp == null) {
throw new IllegalArgumentException("Can not handle managed/back reference '"+refName+"': no back reference property found from type "
+prop.getType());
}
// also: verify that type is compatible
JavaType referredType = _beanType;
JavaType backRefType = backProp.getType();
boolean isContainer = prop.getType().isContainerType();
if (!backRefType.getRawClass().isAssignableFrom(referredType.getRawClass())) {
throw new IllegalArgumentException("Can not handle managed/back reference '"+refName+"': back reference type ("
+backRefType.getRawClass().getName()+") not compatible with managed type ("
+referredType.getRawClass().getName()+")");
}
return new ManagedReferenceProperty(prop, refName, backProp,
_classAnnotations, isContainer);
}
/**
* Method that wraps given property with {@link ObjectIdReferenceProperty}
* in case where object id resolution is required.
*/
protected SettableBeanProperty _resolvedObjectIdProperty(DeserializationContext ctxt,
SettableBeanProperty prop) throws JsonMappingException
{
ObjectIdInfo objectIdInfo = prop.getObjectIdInfo();
JsonDeserializer<Object> valueDeser = prop.getValueDeserializer();
ObjectIdReader objectIdReader = valueDeser.getObjectIdReader();
if (objectIdInfo == null && objectIdReader == null) {
return prop;
}
return new ObjectIdReferenceProperty(prop, objectIdInfo);
}
/**
* Helper method called to see if given property might be so-called unwrapped
* property: these require special handling.
*/
protected SettableBeanProperty _resolveUnwrappedProperty(DeserializationContext ctxt,
SettableBeanProperty prop)
{
AnnotatedMember am = prop.getMember();
if (am != null) {
NameTransformer unwrapper = ctxt.getAnnotationIntrospector().findUnwrappingNameTransformer(am);
if (unwrapper != null) {
JsonDeserializer<Object> orig = prop.getValueDeserializer();
JsonDeserializer<Object> unwrapping = orig.unwrappingDeserializer(unwrapper);
if (unwrapping != orig && unwrapping != null) {
// might be cleaner to create new instance; but difficult to do reliably, so:
return prop.withValueDeserializer(unwrapping);
}
}
}
return null;
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
/**
* Helper method that will handle gruesome details of dealing with properties
* that have non-static inner class as value...
*/
protected SettableBeanProperty _resolveInnerClassValuedProperty(DeserializationContext ctxt,
SettableBeanProperty prop)
{
/* Should we encounter a property that has non-static inner-class
* as value, we need to add some more magic to find the "hidden" constructor...
*/
JsonDeserializer<Object> deser = prop.getValueDeserializer();
// ideally wouldn't rely on it being BeanDeserializerBase; but for now it'll have to do
if (deser instanceof BeanDeserializerBase) {
BeanDeserializerBase bd = (BeanDeserializerBase) deser;
ValueInstantiator vi = bd.getValueInstantiator();
if (!vi.canCreateUsingDefault()) { // no default constructor
Class<?> valueClass = prop.getType().getRawClass();
Class<?> enclosing = ClassUtil.getOuterClass(valueClass);
// and is inner class of the bean class...
if (enclosing != null && enclosing == _beanType.getRawClass()) {
for (Constructor<?> ctor : valueClass.getConstructors()) {
Class<?>[] paramTypes = ctor.getParameterTypes();
if (paramTypes.length == 1 && paramTypes[0] == enclosing) {
if (ctxt.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(ctor, ctxt.isEnabled(MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS));
}
return new InnerClassProperty(prop, ctor);
}
}
}
}
}
return prop;
}
/*
/**********************************************************
/* Public accessors
/**********************************************************
*/
@Override
public boolean isCachable() { return true; }
@Override
public Class<?> handledType() {
return _beanType.getRawClass();
}
/**
* Overridden to return true for those instances that are
* handling value for which Object Identity handling is enabled
* (either via value type or referring property).
*/
@Override
public ObjectIdReader getObjectIdReader() {
return _objectIdReader;
}
public boolean hasProperty(String propertyName) {
return _beanProperties.find(propertyName) != null;
}
public boolean hasViews() {
return _needViewProcesing
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> used as well... need to check that first
if (_objectIdReader != null) {
// 05-Aug-2013, tatu: May use native Object Id
if (p.canReadObjectId()) {
Object id = p.getObjectId();
if (id != null) {
Object ob = typeDeserializer.deserializeTypedFromObject(p, ctxt);
return _handleTypedObjectId(p, ctxt, ob, id);
}
}
// or, Object Ids Jackson explicitly sets
JsonToken t = p.getCurrentToken();
if (t != null) {
// Most commonly, a scalar (int id, uuid String, ...)
if (t.isScalarValue()) {
return deserializeFromObjectId(p, ctxt);
}
// but, with 2.5+, a simple Object-wrapped value also legal:
if (t == JsonToken.START_OBJECT) {
t = p.nextToken();
}
if ((t == JsonToken.FIELD_NAME) && _objectIdReader.maySerializeAsObject()
&& _objectIdReader.isValidReferencePropertyName(p.getCurrentName(), p)) {
return deserializeFromObjectId(p, ctxt);
}
}
}
// In future could check current token... for now this should be enough:
return typeDeserializer.deserializeTypedFromObject(p, ctxt);
}
/**
* Offlined method called to handle "native" Object Id that has been read
* and known to be associated with given deserialized POJO.
*
* @since 2.3
*/
protected Object _handleTypedObjectId(JsonParser p, DeserializationContext ctxt,
Object pojo, Object rawId)
throws IOException
{
// One more challenge: type of id may not be type of property we are expecting
// later on; specifically, numeric ids vs Strings.
JsonDeserializer<Object> idDeser = _objectIdReader.getDeserializer();
final Object id;
// Ok, this is bit ridiculous; let's see if conversion is needed:
if (idDeser.handledType() == rawId.getClass()) {
// nope: already same type
id = rawId;
} else {
id = _convertObjectId(p, ctxt, rawId, idDeser);
}
ReadableObjectId roid = ctxt.findObjectId(
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>id, _objectIdReader.generator, _objectIdReader.resolver);
roid.bindItem(pojo);
// also: may need to set a property value as well
SettableBeanProperty idProp = _objectIdReader.idProperty;
if (idProp != null) {
return idProp.setAndReturn(pojo, id);
}
return pojo;
}
/**
* Helper method we need to do necessary conversion from whatever native object id
* type is, into declared type that Jackson internals expect. This may be
* simple cast (for String ids), or something more complicated; in latter
* case we may need to create bogus content buffer to allow use of
* id deserializer.
*
* @since 2.3
*/
@SuppressWarnings("resource") // TokenBuffers don't need close, nor parser thereof
protected Object _convertObjectId(JsonParser p, DeserializationContext ctxt,
Object rawId, JsonDeserializer<Object> idDeser) throws IOException
{
TokenBuffer buf = new TokenBuffer(p, ctxt);
if (rawId instanceof String) {
buf.writeString((String) rawId);
} else if (rawId instanceof Long) {
buf.writeNumber(((Long) rawId).longValue());
} else if (rawId instanceof Integer) {
buf.writeNumber(((Integer) rawId).intValue());
} else {
// should we worry about UUIDs? They should be fine, right?
// 07-Aug-2014, tatu: Maybe, but not necessarily; had issues with
// Smile format; [dataformat-smile#19], possibly related.
// 01-Sep-2016, tatu: For non-JSON, might want to consider `writeEmbeddedObject`
// but that won't work for default impl (JSON and most dataformats)
buf.writeObject(rawId);
}
JsonParser bufParser = buf.asParser();
bufParser.nextToken();
return idDeser.deserialize(bufParser, ctxt);
}
// NOTE: currently only used by standard BeanDeserializer (not Builder-based)
/**
* Alternative deserialization method used when we expect to see Object Id;
* if so, we will need to ensure that the Id is seen before anything
* else
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> handler method
handleUnknownProperty(p, ctxt, bean, propName);
}
}
/**
* Method called when a JSON property is encountered that has not matching
* setter, any-setter or field, and thus can not be assigned.
*/
@Override
protected void handleUnknownProperty(JsonParser p, DeserializationContext ctxt,
Object beanOrClass, String propName)
throws IOException
{
if (_ignoreAllUnknown) {
p.skipChildren();
return;
}
if (_ignorableProps != null && _ignorableProps.contains(propName)) {
handleIgnoredProperty(p, ctxt, beanOrClass, propName);
}
// Otherwise use default handling (call handler(s); if not
// handled, throw exception or skip depending on settings)
super.handleUnknownProperty(p, ctxt, beanOrClass, propName);
}
/**
* Method called when an explicitly ignored property (one specified with a
* name to match, either by property annotation or class annotation) is encountered.
*
* @since 2.3
*/
protected void handleIgnoredProperty(JsonParser p, DeserializationContext ctxt,
Object beanOrClass, String propName)
throws IOException
{
if (ctxt.isEnabled(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES)) {
throw IgnoredPropertyException.from(p, beanOrClass, propName, getKnownPropertyNames());
}
p.skipChildren();
}
/**
* Method called in cases where we may have polymorphic deserialization
* case: that is, type of Creator-constructed bean is not the type
* of deserializer itself. It should be a sub-class or implementation
* class; either way, we may have more specific deserializer to use
* for handling it.
*
* @param p (optional) If not null, parser that has more properties to handle
* (in addition to buffered properties); if null, all properties are passed
* in buffer
*/
@SuppressWarnings("resource")
protected Object handlePolymorphic(JsonParser p, DeserializationContext ctxt,
Object bean, TokenBuffer unknownTokens)
throws IOException
{
// First things first: maybe there is a more specific deserializer available?
JsonDeserializer<Object> subDeser = _findSubclassDeserializer(ctxt
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>, bean, unknownTokens);
if (subDeser != null) {
if (unknownTokens != null) {
// need to add END_OBJECT marker first
unknownTokens.writeEndObject();
JsonParser p2 = unknownTokens.asParser();
p2.nextToken(); // to get to first data field
bean = subDeser.deserialize(p2, ctxt, bean);
}
// Original parser may also have some leftovers
if (p != null) {
bean = subDeser.deserialize(p, ctxt, bean);
}
return bean;
}
// nope; need to use this deserializer. Unknowns we've seen so far?
if (unknownTokens != null) {
bean = handleUnknownProperties(ctxt, bean, unknownTokens);
}
// and/or things left to process via main parser?
if (p != null) {
bean = deserialize(p, ctxt, bean);
}
return bean;
}
/**
* Helper method called to (try to) locate deserializer for given sub-type of
* type that this deserializer handles.
*/
protected JsonDeserializer<Object> _findSubclassDeserializer(DeserializationContext ctxt,
Object bean, TokenBuffer unknownTokens)
throws IOException
{
JsonDeserializer<Object> subDeser;
// First: maybe we have already created sub-type deserializer?
synchronized (this) {
subDeser = (_subDeserializers == null) ? null : _subDeserializers.get(new ClassKey(bean.getClass()));
}
if (subDeser != null) {
return subDeser;
}
// If not, maybe we can locate one. First, need provider
JavaType type = ctxt.constructType(bean.getClass());
/* 30-Jan-2012, tatu: Ideally we would be passing referring
* property; which in theory we could keep track of via
* ResolvableDeserializer (if we absolutely must...).
* But for now, let's not bother.
*/
// subDeser = ctxt.findValueDeserializer(type, _property);
subDeser = ctxt.findRootValueDeserializer(type);
// Also, need to cache it
if (subDeser != null) {
synchronized (this) {
if (_sub
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Deserializers == null) {
_subDeserializers = new HashMap<ClassKey,JsonDeserializer<Object>>();;
}
_subDeserializers.put(new ClassKey(bean.getClass()), subDeser);
}
}
return subDeser;
}
/*
/**********************************************************
/* Helper methods for error reporting
/**********************************************************
*/
/**
* Method that will modify caught exception (passed in as argument)
* as necessary to include reference information, and to ensure it
* is a subtype of {@link IOException}, or an unchecked exception.
*<p>
* Rules for wrapping and unwrapping are bit complicated; essentially:
*<ul>
* <li>Errors are to be passed as is (if uncovered via unwrapping)
* <li>"Plain" IOExceptions (ones that are not of type
* {@link JsonMappingException} are to be passed as is
*</ul>
*/
public void wrapAndThrow(Throwable t, Object bean, String fieldName, DeserializationContext ctxt)
throws IOException
{
// [JACKSON-55] Need to add reference information
throw JsonMappingException.wrapWithPath(throwOrReturnThrowable(t, ctxt), bean, fieldName);
}
@Deprecated // since 2.4, not used by core Jackson; only relevant for arrays/Collections
public void wrapAndThrow(Throwable t, Object bean, int index, DeserializationContext ctxt) throws IOException {
// [JACKSON-55] Need to add reference information
throw JsonMappingException.wrapWithPath(throwOrReturnThrowable(t, ctxt), bean, index);
}
private Throwable throwOrReturnThrowable(Throwable t, DeserializationContext ctxt)
throws IOException
{
/* 05-Mar-2009, tatu: But one nasty edge is when we get
* StackOverflow: usually due to infinite loop. But that
* often gets hidden within an InvocationTargetException...
*/
while (t instanceof InvocationTargetException && t.getCause() != null) {
t = t.getCause();
}
// Errors to be passed as is
if (t instanceof Error) {
throw (Error) t;
}
boolean wrap = (ctxt == null) || ctxt.isEnabled(DeserializationFeature.WRAP_EXCEPTIONS);
// Ditto for
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.deser.ValueInstantiator;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.type.ReferenceType;
/**
* Base deserializer implementation for properties {@link ReferenceType} values.
* Implements most of functionality, only leaving couple of abstract
* methods for sub-classes to implement
*
* @since 2.8
*/
public abstract class ReferenceTypeDeserializer<T>
extends StdDeserializer<T>
implements ContextualDeserializer
{
private static final long serialVersionUID = 1L;
/**
* Full type of property (or root value) for which this deserializer
* has been constructed and contextualized.
*/
protected final JavaType _fullType;
protected final TypeDeserializer _valueTypeDeserializer;
protected final JsonDeserializer<?> _valueDeserializer;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
public ReferenceTypeDeserializer(JavaType fullType,
TypeDeserializer typeDeser, JsonDeserializer<?> deser)
{
super(fullType);
_fullType = fullType;
_valueDeserializer = deser;
_valueTypeDeserializer = typeDeser;
}
// NOTE: for forwards-compatibility; added in 2.8.5 since 2.9.0 has it
public ReferenceTypeDeserializer(JavaType fullType, ValueInstantiator inst,
TypeDeserializer typeDeser, JsonDeserializer<?> deser) {
this(fullType, typeDeser, deser);
}
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException
{
JsonDeserializer<?> deser = _valueDeserializer;
if (deser == null) {
deser = ctxt.findContextualValueDeserializer(_fullType.getReferencedType(), property);
} else { // otherwise directly assigned, probably not contextual yet:
deser = ctxt.handleSecondaryContextualization(deser, property, _fullType
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>.getReferencedType());
}
TypeDeserializer typeDeser = _valueTypeDeserializer;
if (typeDeser != null) {
typeDeser = typeDeser.forProperty(property);
}
if ((deser == _valueDeserializer) && (typeDeser == _valueTypeDeserializer)) {
return this;
}
return withResolved(typeDeser, deser);
}
/*
/**********************************************************
/* Abstract methods for sub-classes to implement
/**********************************************************
*/
protected abstract ReferenceTypeDeserializer<T> withResolved(TypeDeserializer typeDeser, JsonDeserializer<?> valueDeser);
@Override
public abstract T getNullValue(DeserializationContext ctxt);
public abstract T referenceValue(Object contents);
/*
/**********************************************************
/* Overridden accessors
/**********************************************************
*/
@Override
public JavaType getValueType() { return _fullType; }
/*
/**********************************************************
/* Deserialization
/**********************************************************
*/
@Override
public T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
Object contents = (_valueTypeDeserializer == null)
? _valueDeserializer.deserialize(p, ctxt)
: _valueDeserializer.deserializeWithType(p, ctxt, _valueTypeDeserializer);
return referenceValue(contents);
}
@Override
public Object deserializeWithType(JsonParser p, DeserializationContext ctxt,
TypeDeserializer typeDeserializer) throws IOException
{
final JsonToken t = p.getCurrentToken();
if (t == JsonToken.VALUE_NULL) { // can this actually happen?
return getNullValue(ctxt);
}
// 22-Oct-2015, tatu: This handling is probably not needed (or is wrong), but
// could be result of older (pre-2.7) Jackson trying to serialize natural types.
// Because of this, let's allow for now, unless proven problematic
/*
if ((t != null) && t.isScalarValue()) {
return deserialize(p, ctxt);
}
*/
// 19-Apr-2016, tatu: Alas, due to there typically really being anything for Reference wrapper
// itself, need to just ignore `typeDeser`, use TypeDeserializer we do have for contents
// and it might just work.
if (_valueTypeDeserializer == null) {
return
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.impl;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.util.Collection;
import java.util.Map;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
import com.fasterxml.jackson.databind.util.Annotations;
/**
* Wrapper property that is used to handle managed (forward) properties
* Basically just needs to delegate first to actual forward property, and
* then to back property.
*/
public final class ManagedReferenceProperty
extends SettableBeanProperty
{
private static final long serialVersionUID = 1L;
protected final String _referenceName;
/**
* Flag that indicates whether property to handle is a container type
* (array, Collection, Map) or not.
*/
protected final boolean _isContainer;
protected final SettableBeanProperty _managedProperty;
protected final SettableBeanProperty _backProperty;
public ManagedReferenceProperty(SettableBeanProperty forward, String refName,
SettableBeanProperty backward, Annotations contextAnnotations, boolean isContainer)
{
super(forward.getFullName(), forward.getType(), forward.getWrapperName(),
forward.getValueTypeDeserializer(), contextAnnotations,
forward.getMetadata());
_referenceName = refName;
_managedProperty = forward;
_backProperty = backward;
_isContainer = isContainer;
}
protected ManagedReferenceProperty(ManagedReferenceProperty src, JsonDeserializer<?> deser)
{
super(src, deser);
_referenceName = src._referenceName;
_isContainer = src._isContainer;
_managedProperty = src._managedProperty;
_backProperty = src._backProperty;
}
protected ManagedReferenceProperty(ManagedReferenceProperty src, PropertyName newName) {
super(src, newName);
_referenceName = src._referenceName;
_isContainer = src._isContainer;
_managedProperty = src._managedProperty;
_backProperty = src._backProperty;
}
@Override
public ManagedReferenceProperty withName(PropertyName newName) {
return new ManagedReferenceProperty(this, newName);
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
}
@Override
public ManagedReferenceProperty withValueDeserializer(JsonDeserializer<?> deser) {
return new ManagedReferenceProperty(this, deser);
}
@Override
public void fixAccess(DeserializationConfig config) {
_managedProperty.fixAccess(config);
_backProperty.fixAccess(config);
}
/*
/**********************************************************
/* BeanProperty impl
/**********************************************************
*/
@Override
public <A extends Annotation> A getAnnotation(Class<A> acls) {
return _managedProperty.getAnnotation(acls);
}
@Override public AnnotatedMember getMember() { return _managedProperty.getMember(); }
/*
/**********************************************************
/* Overridden methods
/**********************************************************
*/
@Override
public void deserializeAndSet(JsonParser p, DeserializationContext ctxt, Object instance)
throws IOException {
set(instance, _managedProperty.deserialize(p, ctxt));
}
@Override
public Object deserializeSetAndReturn(JsonParser p, DeserializationContext ctxt, Object instance)
throws IOException {
return setAndReturn(instance, deserialize(p, ctxt));
}
@Override
public final void set(Object instance, Object value) throws IOException {
setAndReturn(instance, value);
}
@Override
public Object setAndReturn(Object instance, Object value) throws IOException
{
/* 04-Feb-2014, tatu: As per [#390], it may be necessary to switch the
* ordering of forward/backward references, and start with back ref.
*/
if (value != null) {
if (_isContainer) { // ok, this gets ugly... but has to do for now
if (value instanceof Object[]) {
for (Object ob : (Object[]) value) {
if (ob != null) { _backProperty.set(ob, instance); }
}
} else if (value instanceof Collection<?>) {
for (Object ob : (Collection<?>) value) {
if (ob != null) { _backProperty.set(ob, instance); }
}
} else if (value instanceof Map<?,?>) {
for (Object ob : ((Map<?,?>) value).values()) {
if (ob != null) { _backProperty.set(ob, instance); }
}
} else {
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>.databind.deser.ContextualDeserializer}
* are implemented, resolution of deserializers occurs before
* contextualization.
*/
public abstract class JsonDeserializer<T>
{
/*
/**********************************************************
/* Main deserialization methods
/**********************************************************
*/
/**
* Method that can be called to ask implementation to deserialize
* JSON content into the value type this serializer handles.
* Returned instance is to be constructed by method itself.
*<p>
* Pre-condition for this method is that the parser points to the
* first event that is part of value to deserializer (and which
* is never JSON 'null' literal, more on this below): for simple
* types it may be the only value; and for structured types the
* Object start marker or a FIELD_NAME.
* </p>
* <p>
* The two possible input conditions for structured types result
* from polymorphism via fields. In the ordinary case, Jackson
* calls this method when it has encountered an OBJECT_START,
* and the method implementation must advance to the next token to
* see the first field name. If the application configures
* polymorphism via a field, then the object looks like the following.
* <pre>
* {
* "@class": "class name",
* ...
* }
* </pre>
* Jackson consumes the two tokens (the <tt>@class</tt> field name
* and its value) in order to learn the class and select the deserializer.
* Thus, the stream is pointing to the FIELD_NAME for the first field
* after the @class. Thus, if you want your method to work correctly
* both with and without polymorphism, you must begin your method with:
* <pre>
* if (jp.getCurrentToken() == JsonToken.START_OBJECT) {
* jp.nextToken();
* }
* </pre>
* This results in the stream pointing to the field name, so that
* the two conditions align.
* <p>
* Post-condition is that the parser will point to the last
* event that is part of deserialized value (or in case deserialization
* fails, event that was not recognized or usable, which may be
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> calling
return typeDeserializer.deserializeTypedFromAny(p, ctxt);
}
/*
/**********************************************************
/* Fluent factory methods for constructing decorated versions
/**********************************************************
*/
/**
* Method that will return deserializer instance that is able
* to handle "unwrapped" value instances
* If no unwrapped instance can be constructed, will simply
* return this object as-is.
*<p>
* Default implementation just returns 'this'
* indicating that no unwrapped variant exists
*/
public JsonDeserializer<T> unwrappingDeserializer(NameTransformer unwrapper) {
return this;
}
/**
* Method that can be called to try to replace deserializer this deserializer
* delegates calls to. If not supported (either this deserializer does not
* delegate anything; or it does not want any changes), should either
* throw {@link UnsupportedOperationException} (if operation does not
* make sense or is not allowed); or return this deserializer as is.
*
* @since 2.1
*/
public JsonDeserializer<?> replaceDelegatee(JsonDeserializer<?> delegatee) {
throw new UnsupportedOperationException();
}
/*
/**********************************************************
/* Introspection methods for figuring out configuration/setup
/* of this deserializer instance and/or type it handles
/**********************************************************
*/
/**
* Method for accessing type of values this deserializer produces.
* Note that this information is not guaranteed to be exact -- it
* may be a more generic (super-type) -- but it should not be
* incorrect (return a non-related type).
*<p>
* Default implementation will return null, which means almost same
* same as returning <code>Object.class</code> would; that is, that
* nothing is known about handled type.
*<p>
* @since 2.3
*/
public Class<?> handledType() { return null; }
/**
* Method called to see if deserializer instance is cachable and
* usable for other properties of same type (type for which instance
* was created).
*<p>
* Note that cached instances are still resolved on per-property basis,
* if instance implements {@link com.fasterxml.jackson.databind.deser.ResolvableDeserializer}:
* cached instance is just as the base. This means that in most cases
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> it is safe to
* cache instances; however, it only makes sense to cache instances
* if instantiation is expensive, or if instances are heavy-weight.
*<p>
* Default implementation returns false, to indicate that no caching
* is done.
*/
public boolean isCachable() { return false; }
/**
* Accessor that can be used to determine if this deserializer uses
* another deserializer for actual deserialization, by delegating
* calls. If so, will return immediate delegate (which itself may
* delegate to further deserializers); otherwise will return null.
*
* @return Deserializer this deserializer delegates calls to, if null;
* null otherwise.
*
* @since 2.1
*/
public JsonDeserializer<?> getDelegatee() {
return null;
}
/**
* Method that will
* either return null to indicate that type being deserializers
* has no concept of properties; or a collection of identifiers
* for which <code>toString</code> will give external property
* name.
* This is only to be used for error reporting and diagnostics
* purposes (most commonly, to accompany "unknown property"
* exception).
*
* @since 2.0
*/
public Collection<Object> getKnownPropertyNames() {
return null;
}
/*
/**********************************************************
/* Other accessors
/**********************************************************
*/
/**
* Method that can be called to determine value to be used for
* representing null values (values deserialized when JSON token
* is {@link JsonToken#VALUE_NULL}). Usually this is simply
* Java null, but for some types (especially primitives) it may be
* necessary to use non-null values.
*<p>
* Since version 2.6 (in which the context argument was added), call is
* expected to be made each and every time a null token needs to
* be handled.
*<p>
* Default implementation simply returns null.
*
* @since 2.6 Added to replace earlier no-arguments variant
*/
public T getNullValue(DeserializationContext ctxt) throws JsonMappingException {
// Change the direction in 2.7
return getNullValue();
}
/**
* Method called to determine value to be used for "empty" values
* (most commonly
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
/**
* @deprecated Since 2.6 Use overloaded variant that takes context argument
*/
@Deprecated
public T getNullValue() { return null; }
/**
* @deprecated Since 2.6 Use overloaded variant that takes context argument
*/
@Deprecated
public T getEmptyValue() { return getNullValue(); }
/*
/**********************************************************
/* Helper classes
/**********************************************************
*/
/**
* This marker class is only to be used with annotations, to
* indicate that <b>no deserializer is configured</b>.
*<p>
* Specifically, this class is to be used as the marker for
* annotation {@link com.fasterxml.jackson.databind.annotation.JsonDeserialize}
*/
public abstract static class None extends JsonDeserializer<Object> {
private None() { } // not to be instantiated
}
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.deser.ResolvableDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.Converter;
/**
* Deserializer implementation where given Java type is first deserialized
* by a standard Jackson deserializer into a delegate type; and then
* this delegate type is converted using a configured
* {@link Converter} into desired target type.
* Common delegate types to use are {@link java.util.Map}
* and {@link com.fasterxml.jackson.databind.JsonNode}.
*<p>
* Note that although types (delegate, target) may be related, they must not be same; trying
* to do this will result in an exception.
*<p>
* Since 2.5 There is {@link StdNodeBasedDeserializer} that is a simplified version
* for cases where intermediate type is {@link JsonNode}
*
* @param <T> Target type to convert to, from delegate type
*
* @since 2.1
*
* @see StdNodeBasedDeserializer
* @see Converter
*/
public class StdDelegatingDeserializer<T>
extends StdDeserializer<T>
implements ContextualDeserializer, ResolvableDeserializer
{
private static final long serialVersionUID = 1L;
protected final Converter<Object,T> _converter;
/**
* Fully resolved delegate type, with generic information if any available.
*/
protected final JavaType _delegateType;
/**
* Underlying serializer for type <code>T</code>.
*/
protected final JsonDeserializer<Object> _delegateDeserializer;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
@SuppressWarnings("unchecked")
public StdDelegatingDeserializer(Converter<?,T> converter)
{
super(Object.class);
_converter = (Converter<Object,T>)converter;
_delegateType = null;
_delegateDeserializer = null;
}
@SuppressWarnings("unchecked")
public StdDelegatingDeserializer(Converter<Object
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>,T> converter,
JavaType delegateType, JsonDeserializer<?> delegateDeserializer)
{
super(delegateType);
_converter = converter;
_delegateType = delegateType;
_delegateDeserializer = (JsonDeserializer<Object>) delegateDeserializer;
}
/**
* @since 2.5
*/
protected StdDelegatingDeserializer(StdDelegatingDeserializer<T> src)
{
super(src);
_converter = src._converter;
_delegateType = src._delegateType;
_delegateDeserializer = src._delegateDeserializer;
}
/**
* Method used for creating resolved contextual instances. Must be
* overridden when sub-classing.
*/
protected StdDelegatingDeserializer<T> withDelegate(Converter<Object,T> converter,
JavaType delegateType, JsonDeserializer<?> delegateDeserializer)
{
if (getClass() != StdDelegatingDeserializer.class) {
throw new IllegalStateException("Sub-class "+getClass().getName()+" must override 'withDelegate'");
}
return new StdDelegatingDeserializer<T>(converter, delegateType, delegateDeserializer);
}
/*
/**********************************************************
/* Contextualization
/**********************************************************
*/
@Override
public void resolve(DeserializationContext ctxt)
throws JsonMappingException
{
if (_delegateDeserializer != null && _delegateDeserializer instanceof ResolvableDeserializer) {
((ResolvableDeserializer) _delegateDeserializer).resolve(ctxt);
}
}
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property)
throws JsonMappingException
{
// First: if already got serializer to delegate to, contextualize it:
if (_delegateDeserializer != null) {
JsonDeserializer<?> deser = ctxt.handleSecondaryContextualization(_delegateDeserializer,
property, _delegateType);
if (deser != _delegateDeserializer) {
return withDelegate(_converter, _delegateType, deser);
}
return this;
}
// Otherwise: figure out what is the fully generic delegate type, then find deserializer
JavaType delegateType = _converter.getInputType(ctxt.getTypeFactory());
return withDelegate(_converter, delegateType,
ctxt.findContextualValueDeserializer(delegateType, property));
}
/*
/**********************************************************
/* Accessors
/**********************************************************
*/
@Override
public JsonDeserializer<?> getDelegatee() {
return _delegateDeserializer;
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.deser.ValueInstantiator;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
import com.fasterxml.jackson.databind.util.ClassUtil;
import com.fasterxml.jackson.databind.util.CompactStringObjectMap;
import com.fasterxml.jackson.databind.util.EnumResolver;
/**
* Deserializer class that can deserialize instances of
* specified Enum class from Strings and Integers.
*/
@JacksonStdImpl // was missing until 2.6
public class EnumDeserializer
extends StdScalarDeserializer<Object>
{
private static final long serialVersionUID = 1L;
protected Object[] _enumsByIndex;
/**
* @since 2.8
*/
private final Enum<?> _enumDefaultValue;
/**
* @since 2.7.3
*/
protected final CompactStringObjectMap _lookupByName;
/**
* Alternatively, we may need a different lookup object if "use toString"
* is defined.
*
* @since 2.7.3
*/
protected CompactStringObjectMap _lookupByToString;
public EnumDeserializer(EnumResolver byNameResolver)
{
super(byNameResolver.getEnumClass());
_lookupByName = byNameResolver.constructLookup();
_enumsByIndex = byNameResolver.getRawEnums();
_enumDefaultValue = byNameResolver.getDefaultValue();
}
/**
* @deprecated Since 2.8
*/
@Deprecated
public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig config,
Class<?> enumClass, AnnotatedMethod factory) {
return deserializerForCreator(config, enumClass, factory, null, null);
}
/**
* Factory method used when Enum instances are to be deserialized
* using a creator (static factory method)
*
* @return Deserializer based on given factory method
*
* @since 2.8
*/
public static JsonDeserializer<?>
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> deserializerForCreator(DeserializationConfig config,
Class<?> enumClass, AnnotatedMethod factory,
ValueInstantiator valueInstantiator, SettableBeanProperty[] creatorProps)
{
if (config.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(factory.getMember(),
config.isEnabled(MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS));
}
return new FactoryBasedEnumDeserializer(enumClass, factory,
factory.getParameterType(0),
valueInstantiator, creatorProps);
}
/**
* Factory method used when Enum instances are to be deserialized
* using a zero-/no-args factory method
*
* @return Deserializer based on given no-args factory method
*
* @since 2.8
*/
public static JsonDeserializer<?> deserializerForNoArgsCreator(DeserializationConfig config,
Class<?> enumClass, AnnotatedMethod factory)
{
if (config.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(factory.getMember(),
config.isEnabled(MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS));
}
return new FactoryBasedEnumDeserializer(enumClass, factory);
}
/*
/**********************************************************
/* Default JsonDeserializer implementation
/**********************************************************
*/
/**
* Because of costs associated with constructing Enum resolvers,
* let's cache instances by default.
*/
@Override
public boolean isCachable() { return true; }
@Override
public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException
{
JsonToken curr = p.getCurrentToken();
// Usually should just get string value:
if (curr == JsonToken.VALUE_STRING || curr == JsonToken.FIELD_NAME) {
CompactStringObjectMap lookup = ctxt.isEnabled(DeserializationFeature.READ_ENUMS_USING_TO_STRING)
? _getToStringLookup(ctxt) : _lookupByName;
final String name = p.getText();
Object result = lookup.find(name);
if (result == null) {
return _deserializeAltString(p, ctxt, lookup, name);
}
return result;
}
// But let's consider int acceptable as well (if within ordinal range)
if (curr == JsonToken.VALUE_NUMBER_INT) {
// ... unless told not to do that
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> *
* @since 2.7
*/
protected ReadableObjectId createReadableObjectId(IdKey key) {
return new ReadableObjectId(key);
}
@Override
public void checkUnresolvedObjectId() throws UnresolvedForwardReference
{
if (_objectIds == null) {
return;
}
// 29-Dec-2014, tatu: As per [databind#299], may also just let unresolved refs be...
if (!isEnabled(DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS)) {
return;
}
UnresolvedForwardReference exception = null;
for (Entry<IdKey,ReadableObjectId> entry : _objectIds.entrySet()) {
ReadableObjectId roid = entry.getValue();
if (!roid.hasReferringProperties()) {
continue;
}
// as per [databind#675], allow resolution at this point
if (tryToResolveUnresolvedObjectId(roid)) {
continue;
}
if (exception == null) {
exception = new UnresolvedForwardReference(getParser(), "Unresolved forward references for: ");
}
Object key = roid.getKey().key;
for (Iterator<Referring> iterator = roid.referringProperties(); iterator.hasNext(); ) {
Referring referring = iterator.next();
exception.addUnresolvedId(key, referring.getBeanType(), referring.getLocation());
}
}
if (exception != null) {
throw exception;
}
}
/**
* Overridable helper method called to try to resolve otherwise unresolvable {@link ReadableObjectId};
* and if this succeeds, return <code>true</code> to indicate problem has been resolved in
* some way, so that caller can avoid reporting it as an error.
*<p>
* Default implementation simply calls {@link ReadableObjectId#tryToResolveUnresolved} and
* returns whatever it returns.
*
* @since 2.6
*/
protected boolean tryToResolveUnresolvedObjectId(ReadableObjectId roid)
{
return roid.tryToResolveUnresolved(this);
}
/*
/**********************************************************
/* Abstract methods impls, other factory methods
/**********************************************************
*/
@SuppressWarnings("unchecked")
@Override
public JsonDeserializer<Object> deserializerInstance(
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Annotated ann, Object deserDef)
throws JsonMappingException
{
if (deserDef == null) {
return null;
}
JsonDeserializer<?> deser;
if (deserDef instanceof JsonDeserializer) {
deser = (JsonDeserializer<?>) deserDef;
} else {
/* Alas, there's no way to force return type of "either class
* X or Y" -- need to throw an exception after the fact
*/
if (!(deserDef instanceof Class)) {
throw new IllegalStateException("AnnotationIntrospector returned deserializer definition of type "+deserDef.getClass().getName()+"; expected type JsonDeserializer or Class<JsonDeserializer> instead");
}
Class<?> deserClass = (Class<?>)deserDef;
// there are some known "no class" markers to consider too:
if (deserClass == JsonDeserializer.None.class || ClassUtil.isBogusClass(deserClass)) {
return null;
}
if (!JsonDeserializer.class.isAssignableFrom(deserClass)) {
throw new IllegalStateException("AnnotationIntrospector returned Class "+deserClass.getName()+"; expected Class<JsonDeserializer>");
}
HandlerInstantiator hi = _config.getHandlerInstantiator();
deser = (hi == null) ? null : hi.deserializerInstance(_config, ann, deserClass);
if (deser == null) {
deser = (JsonDeserializer<?>) ClassUtil.createInstance(deserClass,
_config.canOverrideAccessModifiers());
}
}
// First: need to resolve
if (deser instanceof ResolvableDeserializer) {
((ResolvableDeserializer) deser).resolve(this);
}
return (JsonDeserializer<Object>) deser;
}
@Override
public final KeyDeserializer keyDeserializerInstance(Annotated ann, Object deserDef)
throws JsonMappingException
{
if (deserDef == null) {
return null;
}
KeyDeserializer deser;
if (deserDef instanceof KeyDeserializer) {
deser = (KeyDeserializer) deserDef;
} else {
if (!(deserDef instanceof Class)) {
throw new IllegalStateException("AnnotationIntrospector returned key deserializer definition of type "
+deserDef.getClass().getName()
+"; expected type KeyDeserializer or Class<KeyDeserializer> instead");
}
Class<?> deserClass = (Class<?>)de
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>serDef;
// there are some known "no class" markers to consider too:
if (deserClass == KeyDeserializer.None.class || ClassUtil.isBogusClass(deserClass)) {
return null;
}
if (!KeyDeserializer.class.isAssignableFrom(deserClass)) {
throw new IllegalStateException("AnnotationIntrospector returned Class "+deserClass.getName()
+"; expected Class<KeyDeserializer>");
}
HandlerInstantiator hi = _config.getHandlerInstantiator();
deser = (hi == null) ? null : hi.keyDeserializerInstance(_config, ann, deserClass);
if (deser == null) {
deser = (KeyDeserializer) ClassUtil.createInstance(deserClass,
_config.canOverrideAccessModifiers());
}
}
// First: need to resolve
if (deser instanceof ResolvableDeserializer) {
((ResolvableDeserializer) deser).resolve(this);
}
return deser;
}
/*
/**********************************************************
/* Extended API
/**********************************************************
*/
/**
* Fluent factory method used for constructing a blueprint instance
* with different factory
*/
public abstract DefaultDeserializationContext with(DeserializerFactory factory);
/**
* Method called to create actual usable per-deserialization
* context instance.
*/
public abstract DefaultDeserializationContext createInstance(
DeserializationConfig config, JsonParser jp, InjectableValues values);
/*
/**********************************************************
/* And then the concrete implementation class
/**********************************************************
*/
/**
* Actual full concrete implementation
*/
public final static class Impl extends DefaultDeserializationContext
{
private static final long serialVersionUID = 1L;
/**
* Default constructor for a blueprint object, which will use the standard
* {@link DeserializerCache}, given factory.
*/
public Impl(DeserializerFactory df) {
super(df, null);
}
protected Impl(Impl src,
DeserializationConfig config, JsonParser jp, InjectableValues values) {
super(src, config, jp, values);
}
protected Impl(Impl src) { super(src); }
protected Impl(Impl src, DeserializerFactory factory) {
super(src, factory);
}
@Override
public DefaultDeserializationContext copy() {
if (getClass() != Impl.class) {
return super.copy();
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.ext;
import java.beans.ConstructorProperties;
import java.beans.Transient;
import java.nio.file.Path;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.PropertyName;
import com.fasterxml.jackson.databind.introspect.Annotated;
import com.fasterxml.jackson.databind.introspect.AnnotatedParameter;
import com.fasterxml.jackson.databind.introspect.AnnotatedWithParams;
/**
* @since 2.8
*/
public class Java7SupportImpl extends Java7Support
{
@SuppressWarnings("unused") // compiler warns, just needed side-effects
private final Class<?> _bogus;
public Java7SupportImpl() {
// Trigger loading of annotations that only JDK 7 has...
Class<?> cls = Transient.class;
cls = ConstructorProperties.class;
_bogus = cls;
}
@Override
public Class<?> getClassJavaNioFilePath() {
return Path.class;
}
@Override
public JsonDeserializer<?> getDeserializerForJavaNioFilePath(Class<?> rawType) {
if (rawType == Path.class) {
return new NioPathDeserializer();
}
return null;
}
@Override
public JsonSerializer<?> getSerializerForJavaNioFilePath(Class<?> rawType) {
if (Path.class.isAssignableFrom(rawType)) {
return new NioPathSerializer();
}
return null;
}
@Override
public Boolean findTransient(Annotated a) {
Transient t = a.getAnnotation(Transient.class);
if (t != null) {
return t.value();
}
return null;
}
@Override
public Boolean hasCreatorAnnotation(Annotated a) {
ConstructorProperties props = a.getAnnotation(ConstructorProperties.class);
// 08-Nov-2015, tatu: One possible check would be to ensure there is at least
// one name iff constructor has arguments. But seems unnecessary for now.
if (props != null) {
return Boolean.TRUE;
}
return null;
}
@Override
public PropertyName findConstructorName(AnnotatedParameter p)
{
AnnotatedWithParams ctor = p.getOwner();
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser;
import java.io.IOException;
import java.lang.annotation.Annotation;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.impl.FailingDeserializer;
import com.fasterxml.jackson.databind.introspect.*;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonObjectFormatVisitor;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.Annotations;
import com.fasterxml.jackson.databind.util.ViewMatcher;
/**
* Base class for deserializable properties of a bean: contains
* both type and name definitions, and reflection-based set functionality.
* Concrete sub-classes implement details, so that field- and
* setter-backed properties, as well as a few more esoteric variations,
* can be handled.
*/
@SuppressWarnings("serial")
public abstract class SettableBeanProperty
extends ConcreteBeanPropertyBase
implements java.io.Serializable
{
/**
* To avoid nasty NPEs, let's use a placeholder for _valueDeserializer,
* if real deserializer is not (yet) available.
*
* @since 2.2
*/
protected static final JsonDeserializer<Object> MISSING_VALUE_DESERIALIZER = new FailingDeserializer(
"No _valueDeserializer assigned");
/**
* Logical name of the property (often but not always derived
* from the setter method name)
*/
protected final PropertyName _propName;
/**
* Base type for property; may be a supertype of actual value.
*/
protected final JavaType _type;
/**
* @since 2.2
*/
protected final PropertyName _wrapperName;
/**
* Class that contains this property (either class that declares
* the property or one of its subclasses), class that is
* deserialized using deserializer that contains this property.
*/
protected final transient Annotations _contextAnnotations;
/**
* Deserializer used for handling property value.
*<p>
* NOTE: has been immutable since 2.3
*/
protected final JsonDeserializer<Object> _valueDeserializer;
/**
* If
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Deser, Annotations contextAnnotations,
PropertyMetadata metadata)
{
super(metadata);
// 09-Jan-2009, tatu: Intern()ing makes sense since Jackson parsed
// field names are (usually) interned too, hence lookups will be faster.
// 23-Oct-2009, tatu: should this be disabled wrt [JACKSON-180]?
// Probably need not, given that namespace of field/method names
// is not unbounded, unlike potential JSON names.
if (propName == null) {
_propName = PropertyName.NO_NAME;
} else {
_propName = propName.internSimpleName();
}
_type = type;
_wrapperName = wrapper;
_contextAnnotations = contextAnnotations;
_viewMatcher = null;
// 30-Jan-2012, tatu: Important: contextualize TypeDeserializer now...
if (typeDeser != null) {
typeDeser = typeDeser.forProperty(this);
}
_valueTypeDeserializer = typeDeser;
_valueDeserializer = MISSING_VALUE_DESERIALIZER;
}
/**
* Constructor only used by {@link com.fasterxml.jackson.databind.deser.impl.ObjectIdValueProperty}.
*
* @since 2.3
*/
protected SettableBeanProperty(PropertyName propName, JavaType type,
PropertyMetadata metadata, JsonDeserializer<Object> valueDeser)
{
super(metadata);
// as with above ctor, intern()ing probably fine
if (propName == null) {
_propName = PropertyName.NO_NAME;
} else {
_propName = propName.internSimpleName();
}
_type = type;
_wrapperName = null;
_contextAnnotations = null;
_viewMatcher = null;
_valueTypeDeserializer = null;
_valueDeserializer = valueDeser;
}
/**
* Basic copy-constructor for sub-classes to use.
*/
protected SettableBeanProperty(SettableBeanProperty src)
{
super(src);
_propName = src._propName;
_type = src._type;
_wrapperName = src._wrapperName;
_contextAnnotations
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> = src._contextAnnotations;
_valueDeserializer = src._valueDeserializer;
_valueTypeDeserializer = src._valueTypeDeserializer;
_managedReferenceName = src._managedReferenceName;
_propertyIndex = src._propertyIndex;
_viewMatcher = src._viewMatcher;
}
/**
* Copy-with-deserializer-change constructor for sub-classes to use.
*/
@SuppressWarnings("unchecked")
protected SettableBeanProperty(SettableBeanProperty src, JsonDeserializer<?> deser)
{
super(src);
_propName = src._propName;
_type = src._type;
_wrapperName = src._wrapperName;
_contextAnnotations = src._contextAnnotations;
_valueTypeDeserializer = src._valueTypeDeserializer;
_managedReferenceName = src._managedReferenceName;
_propertyIndex = src._propertyIndex;
if (deser == null) {
_valueDeserializer = MISSING_VALUE_DESERIALIZER;
} else {
_valueDeserializer = (JsonDeserializer<Object>) deser;
}
_viewMatcher = src._viewMatcher;
}
/**
* Copy-with-deserializer-change constructor for sub-classes to use.
*/
protected SettableBeanProperty(SettableBeanProperty src, PropertyName newName)
{
super(src);
_propName = newName;
_type = src._type;
_wrapperName = src._wrapperName;
_contextAnnotations = src._contextAnnotations;
_valueDeserializer = src._valueDeserializer;
_valueTypeDeserializer = src._valueTypeDeserializer;
_managedReferenceName = src._managedReferenceName;
_propertyIndex = src._propertyIndex;
_viewMatcher = src._viewMatcher;
}
/**
* Fluent factory method for constructing and returning a new instance
* with specified value deserializer.
* Note that this method should NOT change configuration of this instance.
*
* @param deser Deserializer to assign to the new property instance
*
* @return Newly constructed instance, if value deserializer differs from the
* one used for this instance; or 'this' if not.
*/
public abstract SettableBeanProperty withValueDeserializer(JsonDeserializer<?> deser);
/**
* Fluent factory method for constructing and returning a new instance
* with specified property name.
* Note that this method should NOT change configuration of this
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> getWrapperName() {
return _wrapperName;
}
@Override
public abstract AnnotatedMember getMember();
@Override
public abstract <A extends Annotation> A getAnnotation(Class<A> acls);
@Override
public <A extends Annotation> A getContextAnnotation(Class<A> acls) {
return _contextAnnotations.get(acls);
}
@Override
public void depositSchemaProperty(JsonObjectFormatVisitor objectVisitor,
SerializerProvider provider)
throws JsonMappingException
{
if (isRequired()) {
objectVisitor.property(this);
} else {
objectVisitor.optionalProperty(this);
}
}
/*
/**********************************************************
/* Accessors
/**********************************************************
*/
protected final Class<?> getDeclaringClass() {
return getMember().getDeclaringClass();
}
public String getManagedReferenceName() { return _managedReferenceName; }
public ObjectIdInfo getObjectIdInfo() { return _objectIdInfo; }
public boolean hasValueDeserializer() {
return (_valueDeserializer != null) && (_valueDeserializer != MISSING_VALUE_DESERIALIZER);
}
public boolean hasValueTypeDeserializer() { return (_valueTypeDeserializer != null); }
public JsonDeserializer<Object> getValueDeserializer() {
JsonDeserializer<Object> deser = _valueDeserializer;
if (deser == MISSING_VALUE_DESERIALIZER) {
return null;
}
return deser;
}
public TypeDeserializer getValueTypeDeserializer() { return _valueTypeDeserializer; }
public boolean visibleInView(Class<?> activeView) {
return (_viewMatcher == null) || _viewMatcher.isVisibleForView(activeView);
}
public boolean hasViews() { return _viewMatcher != null; }
/**
* Method for accessing unique index of this property; indexes are
* assigned once all properties of a {@link BeanDeserializer} have
* been collected.
*
* @return Index of this property
*/
public int getPropertyIndex() { return _propertyIndex; }
/**
* Method for accessing index of the creator property: for other
* types of properties will simply return -1.
*
* @since 2.1
*/
public int getCreatorIndex() { return -1; }
/**
* Accessor for id of injectable value, if this bean property supports
* value injection.
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
/**
* Deserializer for {@link EnumMap} values.
* <p>
* Note: casting within this class is all messed up -- just could not figure out a way
* to properly deal with recursive definition of "EnumMap<K extends Enum<K>, V>
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public class EnumMapDeserializer
extends ContainerDeserializerBase<EnumMap<?,?>>
implements ContextualDeserializer
{
private static final long serialVersionUID = 1;
protected final JavaType _mapType;
protected final Class<?> _enumClass;
protected KeyDeserializer _keyDeserializer;
protected JsonDeserializer<Object> _valueDeserializer;
/**
* If value instances have polymorphic type information, this
* is the type deserializer that can handle it
*/
protected final TypeDeserializer _valueTypeDeserializer;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
public EnumMapDeserializer(JavaType mapType, KeyDeserializer keyDeserializer, JsonDeserializer<?> valueDeser, TypeDeserializer valueTypeDeser)
{
super(mapType);
_mapType = mapType;
_enumClass = mapType.getKeyType().getRawClass();
_keyDeserializer = keyDeserializer;
_valueDeserializer = (JsonDeserializer<Object>) valueDeser;
_valueTypeDeserializer = valueTypeDeser;
}
public EnumMapDeserializer withResolved(KeyDeserializer keyDeserializer, JsonDeserializer<?> valueDeserializer, TypeDeserializer valueTypeDeser)
{
if ((keyDeserializer == _keyDeserializer) && (valueDeserializer == _valueDeserializer) && (valueTypeDeser == _valueTypeDeserializer)) {
return this;
}
return new EnumMapDeserializer(_mapType, keyDeserializer, valueDeserializer, _valueTypeDeserializer);
}
/**
* Method called to finalize setup of this deserializer,
* when it is known for which property deserializer is needed for.
*/
@Override
public JsonDeserializer<?> createContextual
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException
{
// note: instead of finding key deserializer, with enums we actually
// work with regular deserializers (less code duplication; but not
// quite as clean as it ought to be)
KeyDeserializer kd = _keyDeserializer;
if (kd == null) {
kd = ctxt.findKeyDeserializer(_mapType.getKeyType(), property);
}
JsonDeserializer<?> vd = _valueDeserializer;
final JavaType vt = _mapType.getContentType();
if (vd == null) {
vd = ctxt.findContextualValueDeserializer(vt, property);
} else { // if directly assigned, probably not yet contextual, so:
vd = ctxt.handleSecondaryContextualization(vd, property, vt);
}
TypeDeserializer vtd = _valueTypeDeserializer;
if (vtd != null) {
vtd = vtd.forProperty(property);
}
return withResolved(kd, vd, vtd);
}
/**
* Because of costs associated with constructing Enum resolvers,
* let's cache instances by default.
*/
@Override
public boolean isCachable() {
// Important: do NOT cache if polymorphic values
return (_valueDeserializer == null)
&& (_keyDeserializer == null)
&& (_valueTypeDeserializer == null);
}
/*
/**********************************************************
/* ContainerDeserializerBase API
/**********************************************************
*/
@Override
public JavaType getContentType() {
return _mapType.getContentType();
}
@Override
public JsonDeserializer<Object> getContentDeserializer() {
return _valueDeserializer;
}
/*
/**********************************************************
/* Actual deserialization
/**********************************************************
*/
@Override
public EnumMap<?,?> deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// Ok: must point to START_OBJECT
if (p.getCurrentToken() != JsonToken.START_OBJECT) {
return _deserializeFromEmpty(p, ctxt);
}
EnumMap result = constructMap();
final JsonDeserializer<Object> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
while ((p.nextToken()) == JsonToken.FIELD_NAME) {
String keyName = p.getCurrentName(); // just for error message
//
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.util.concurrent.atomic.AtomicReference;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
public class AtomicReferenceDeserializer
extends ReferenceTypeDeserializer<AtomicReference<Object>>
{
private static final long serialVersionUID = 1L;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
@Deprecated // since 2.8
public AtomicReferenceDeserializer(JavaType fullType) {
this(fullType, null, null);
}
public AtomicReferenceDeserializer(JavaType fullType,
TypeDeserializer typeDeser, JsonDeserializer<?> deser)
{
super(fullType, typeDeser, deser);
}
/*
/**********************************************************
/* Abstract method implementations
/**********************************************************
*/
@Override
public AtomicReferenceDeserializer withResolved(TypeDeserializer typeDeser, JsonDeserializer<?> valueDeser) {
return new AtomicReferenceDeserializer(_fullType, typeDeser, valueDeser);
}
@Override
public AtomicReference<Object> getNullValue(DeserializationContext ctxt) {
return new AtomicReference<Object>();
}
@Override
public AtomicReference<Object> referenceValue(Object contents) {
return new AtomicReference<Object>(contents);
}
/*
@Override
public Object deserializeWithType(JsonParser p, DeserializationContext ctxt,
TypeDeserializer typeDeser) throws IOException
{
final JsonToken t = p.getCurrentToken();
if (t == JsonToken.VALUE_NULL) { // can this actually happen?
return getNullValue(ctxt);
}
// 22-Oct-2015, tatu: This handling is probably not needed (or is wrong), but
// could be result of older (pre-2.7) Jackson trying to serialize natural types.
// Because of this, let's allow for now, unless proven problematic
if ((t != null) && t.isScalarValue()) {
return deserialize(p, ctxt);
}
// 19-Apr-2016, tatu: Alas, due to there not really being anything for AtomicReference
// itself, need to just ignore `typeDeser`, use TypeDeserializer we do have for contents
//
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.nio.ByteBuffer;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import com.fasterxml.jackson.databind.*;
/**
* Container class that contains serializers for JDK types that
* require special handling for some reason.
*/
public class JdkDeserializers
{
private final static HashSet<String> _classNames = new HashSet<String>();
static {
// note: can skip primitive types; other ways to check them:
Class<?>[] types = new Class<?>[] {
UUID.class,
AtomicBoolean.class,
StackTraceElement.class,
ByteBuffer.class
};
for (Class<?> cls : types) { _classNames.add(cls.getName()); }
for (Class<?> cls : FromStringDeserializer.types()) { _classNames.add(cls.getName()); }
}
public static JsonDeserializer<?> find(Class<?> rawType, String clsName)
{
if (_classNames.contains(clsName)) {
JsonDeserializer<?> d = FromStringDeserializer.findDeserializer(rawType);
if (d != null) {
return d;
}
if (rawType == UUID.class) {
return new UUIDDeserializer();
}
if (rawType == StackTraceElement.class) {
return new StackTraceElementDeserializer();
}
if (rawType == AtomicBoolean.class) {
// (note: AtomicInteger/Long work due to single-arg constructor. For now?
return new AtomicBooleanDeserializer();
}
if (rawType == ByteBuffer.class) {
return new ByteBufferDeserializer();
}
}
return null;
}
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>)) {
factoryName = SERIALIZERS_FOR_JAVAX_XML;
} else {
return null;
}
Object ob = instantiate(factoryName);
if (ob == null) { // could warn, if we had logging system (j.u.l?)
return null;
}
return ((Serializers) ob).findSerializer(config, type, beanDesc);
}
public JsonDeserializer<?> findDeserializer(JavaType type, DeserializationConfig config,
BeanDescription beanDesc)
throws JsonMappingException
{
final Class<?> rawType = type.getRawClass();
if (_jdk7Helper != null) {
JsonDeserializer<?> deser = _jdk7Helper.getDeserializerForJavaNioFilePath(rawType);
if (deser != null) {
return deser;
}
}
if ((CLASS_DOM_NODE != null) && CLASS_DOM_NODE.isAssignableFrom(rawType)) {
return (JsonDeserializer<?>) instantiate(DESERIALIZER_FOR_DOM_NODE);
}
if ((CLASS_DOM_DOCUMENT != null) && CLASS_DOM_DOCUMENT.isAssignableFrom(rawType)) {
return (JsonDeserializer<?>) instantiate(DESERIALIZER_FOR_DOM_DOCUMENT);
}
String className = rawType.getName();
String factoryName;
if (className.startsWith(PACKAGE_PREFIX_JAVAX_XML)
|| hasSuperClassStartingWith(rawType, PACKAGE_PREFIX_JAVAX_XML)) {
factoryName = DESERIALIZERS_FOR_JAVAX_XML;
} else {
return null;
}
Object ob = instantiate(factoryName);
if (ob == null) { // could warn, if we had logging system (j.u.l?)
return null;
}
return ((Deserializers) ob).findBeanDeserializer(type, config, beanDesc);
}
/*
/**********************************************************
/* Internal helper methods
/**********************************************************
*/
private Object instantiate(String className)
{
try {
return Class.forName(className).newInstance();
} catch (LinkageError e) { }
// too many different kinds to enumerate here:
catch (Exception e) { }
return null;
}
/**
* Since 2.7 we only need to check for class extension, as all implemented
* types are classes
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> JsonDeserializer<Object> _valueDeserializer;
/**
* If value instances have polymorphic type information, this
* is the type deserializer that can handle it
*/
protected final TypeDeserializer _valueTypeDeserializer;
// // Instance construction settings:
protected final ValueInstantiator _valueInstantiator;
protected final boolean _hasDefaultCreator;
/**
* Deserializer that is used iff delegate-based creator is
* to be used for deserializing from JSON Object.
*/
protected JsonDeserializer<Object> _delegateDeserializer;
/**
* If the Map is to be instantiated using non-default constructor
* or factory method
* that takes one or more named properties as argument(s),
* this creator is used for instantiation.
*/
protected PropertyBasedCreator _propertyBasedCreator;
// // Any properties to ignore if seen?
protected Set<String> _ignorableProperties;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
public MapDeserializer(JavaType mapType, ValueInstantiator valueInstantiator,
KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser,
TypeDeserializer valueTypeDeser)
{
super(mapType);
_mapType = mapType;
_keyDeserializer = keyDeser;
_valueDeserializer = valueDeser;
_valueTypeDeserializer = valueTypeDeser;
_valueInstantiator = valueInstantiator;
_hasDefaultCreator = valueInstantiator.canCreateUsingDefault();
_delegateDeserializer = null;
_propertyBasedCreator = null;
_standardStringKey = _isStdKeyDeser(mapType, keyDeser);
}
/**
* Copy-constructor that can be used by sub-classes to allow
* copy-on-write styling copying of settings of an existing instance.
*/
protected MapDeserializer(MapDeserializer src)
{
super(src._mapType);
_mapType = src._mapType;
_keyDeserializer = src._keyDeserializer;
_valueDeserializer = src._valueDeserializer;
_valueTypeDeserializer = src._valueTypeDeserializer;
_valueInstantiator = src._valueInstantiator;
_propertyBasedCreator = src._propertyBasedCreator;
_delegateDeserializer = src._delegateDeserializer;
_hasDefaultCreator = src._hasDefaultCreator;
// should we make a copy here?
_ignorableProperties = src
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>._ignorableProperties;
_standardStringKey = src._standardStringKey;
}
protected MapDeserializer(MapDeserializer src,
KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser,
TypeDeserializer valueTypeDeser,
Set<String> ignorable)
{
super(src._mapType);
_mapType = src._mapType;
_keyDeserializer = keyDeser;
_valueDeserializer = valueDeser;
_valueTypeDeserializer = valueTypeDeser;
_valueInstantiator = src._valueInstantiator;
_propertyBasedCreator = src._propertyBasedCreator;
_delegateDeserializer = src._delegateDeserializer;
_hasDefaultCreator = src._hasDefaultCreator;
_ignorableProperties = ignorable;
_standardStringKey = _isStdKeyDeser(_mapType, keyDeser);
}
/**
* Fluent factory method used to create a copy with slightly
* different settings. When sub-classing, MUST be overridden.
*/
@SuppressWarnings("unchecked")
protected MapDeserializer withResolved(KeyDeserializer keyDeser,
TypeDeserializer valueTypeDeser, JsonDeserializer<?> valueDeser,
Set<String> ignorable)
{
if ((_keyDeserializer == keyDeser) && (_valueDeserializer == valueDeser)
&& (_valueTypeDeserializer == valueTypeDeser) && (_ignorableProperties == ignorable)) {
return this;
}
return new MapDeserializer(this,
keyDeser, (JsonDeserializer<Object>) valueDeser, valueTypeDeser, ignorable);
}
/**
* Helper method used to check whether we can just use the default key
* deserialization, where JSON String becomes Java String.
*/
protected final boolean _isStdKeyDeser(JavaType mapType, KeyDeserializer keyDeser)
{
if (keyDeser == null) {
return true;
}
JavaType keyType = mapType.getKeyType();
if (keyType == null) { // assumed to be Object
return true;
}
Class<?> rawKeyType = keyType.getRawClass();
return ((rawKeyType == String.class || rawKeyType == Object.class)
&& isDefaultKeyDeserializer(keyDeser));
}
public void setIgnorableProperties(String[] ignorable) {
_ignorableProperties = (ignorable == null
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> finalize setup of this deserializer,
* when it is known for which property deserializer is needed for.
*/
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
KeyDeserializer kd = _keyDeserializer;
if (kd == null) {
kd = ctxt.findKeyDeserializer(_mapType.getKeyType(), property);
} else {
if (kd instanceof ContextualKeyDeserializer) {
kd = ((ContextualKeyDeserializer) kd).createContextual(ctxt, property);
}
}
JsonDeserializer<?> vd = _valueDeserializer;
// [databind#125]: May have a content converter
if (property != null) {
vd = findConvertingContentDeserializer(ctxt, property, vd);
}
final JavaType vt = _mapType.getContentType();
if (vd == null) {
vd = ctxt.findContextualValueDeserializer(vt, property);
} else { // if directly assigned, probably not yet contextual, so:
vd = ctxt.handleSecondaryContextualization(vd, property, vt);
}
TypeDeserializer vtd = _valueTypeDeserializer;
if (vtd != null) {
vtd = vtd.forProperty(property);
}
Set<String> ignored = _ignorableProperties;
AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
if (intr != null && property != null) {
AnnotatedMember member = property.getMember();
if (member != null) {
JsonIgnoreProperties.Value ignorals = intr.findPropertyIgnorals(member);
if (ignorals != null) {
Set<String> ignoresToAdd = ignorals.findIgnoredForDeserialization();
if (!ignoresToAdd.isEmpty()) {
ignored = (ignored == null) ? new HashSet<String>() : new HashSet<String>(ignored);
for (String str : ignoresToAdd) {
ignored.add(str);
}
}
}
}
}
return withResolved(kd, vtd, vd, ignored);
}
/*
/**********************************************************
/* ContainerDeserializerBase API
/**********************************************************
*/
@Override
public JavaType getContentType() {
return _mapType.getContentType();
}
@Override
public JsonDeserializer<Object
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> but
return _deserializeFromEmpty(p, ctxt);
}
final Map<Object,Object> result = (Map<Object,Object>) _valueInstantiator.createUsingDefault(ctxt);
if (_standardStringKey) {
_readAndBindStringKeyMap(p, ctxt, result);
return result;
}
_readAndBind(p, ctxt, result);
return result;
}
@SuppressWarnings("unchecked")
@Override
public Map<Object,Object> deserialize(JsonParser p, DeserializationContext ctxt,
Map<Object,Object> result)
throws IOException
{
// [databind#631]: Assign current value, to be accessible by custom serializers
p.setCurrentValue(result);
// Ok: must point to START_OBJECT or FIELD_NAME
JsonToken t = p.getCurrentToken();
if (t != JsonToken.START_OBJECT && t != JsonToken.FIELD_NAME) {
return (Map<Object,Object>) ctxt.handleUnexpectedToken(getMapClass(), p);
}
if (_standardStringKey) {
_readAndBindStringKeyMap(p, ctxt, result);
return result;
}
_readAndBind(p, ctxt, result);
return result;
}
@Override
public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
TypeDeserializer typeDeserializer)
throws IOException, JsonProcessingException
{
// In future could check current token... for now this should be enough:
return typeDeserializer.deserializeTypedFromObject(jp, ctxt);
}
/*
/**********************************************************
/* Other public accessors
/**********************************************************
*/
@SuppressWarnings("unchecked")
public final Class<?> getMapClass() { return (Class<Map<Object,Object>>) _mapType.getRawClass(); }
@Override public JavaType getValueType() { return _mapType; }
/*
/**********************************************************
/* Internal methods
/**********************************************************
*/
protected final void _readAndBind(JsonParser p, DeserializationContext ctxt,
Map<Object,Object> result) throws IOException
{
final KeyDeserializer keyDes = _keyDeserializer;
final JsonDeserializer<Object> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
MapReferringAccumulator referringAccumulator = null;
boolean useObjectId = valueDes.getObjectId
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Reader() != null;
if (useObjectId) {
referringAccumulator = new MapReferringAccumulator(_mapType.getContentType().getRawClass(), result);
}
String keyStr;
if (p.isExpectedStartObjectToken()) {
keyStr = p.nextFieldName();
} else {
JsonToken t = p.getCurrentToken();
if (t == JsonToken.END_OBJECT) {
return;
}
if (t != JsonToken.FIELD_NAME) {
ctxt.reportWrongTokenException(p, JsonToken.FIELD_NAME, null);
}
keyStr = p.getCurrentName();
}
for (; keyStr != null; keyStr = p.nextFieldName()) {
Object key = keyDes.deserializeKey(keyStr, ctxt);
// And then the value...
JsonToken t = p.nextToken();
if (_ignorableProperties != null && _ignorableProperties.contains(keyStr)) {
p.skipChildren();
continue;
}
try {
// Note: must handle null explicitly here; value deserializers won't
Object value;
if (t == JsonToken.VALUE_NULL) {
value = valueDes.getNullValue(ctxt);
} else if (typeDeser == null) {
value = valueDes.deserialize(p, ctxt);
} else {
value = valueDes.deserializeWithType(p, ctxt, typeDeser);
}
if (useObjectId) {
referringAccumulator.put(key, value);
} else {
result.put(key, value);
}
} catch (UnresolvedForwardReference reference) {
handleUnresolvedReference(p, referringAccumulator, key, reference);
} catch (Exception e) {
wrapAndThrow(e, result, keyStr);
}
}
}
/**
* Optimized method used when keys can be deserialized as plain old
* {@link java.lang.String}s, and there is no custom deserialized
* specified.
*/
protected final void _readAndBindStringKeyMap(JsonParser p, DeserializationContext ctxt,
Map<Object,Object> result) throws IOException
{
final JsonDeserializer<Object> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
MapReferringAccumulator referringAccumulator = null;
boolean useObjectId =
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> (valueDes.getObjectIdReader() != null);
if (useObjectId) {
referringAccumulator = new MapReferringAccumulator(_mapType.getContentType().getRawClass(), result);
}
String key;
if (p.isExpectedStartObjectToken()) {
key = p.nextFieldName();
} else {
JsonToken t = p.getCurrentToken();
if (t == JsonToken.END_OBJECT) {
return;
}
if (t != JsonToken.FIELD_NAME) {
ctxt.reportWrongTokenException(p, JsonToken.FIELD_NAME, null);
}
key = p.getCurrentName();
}
for (; key != null; key = p.nextFieldName()) {
JsonToken t = p.nextToken();
if (_ignorableProperties != null && _ignorableProperties.contains(key)) {
p.skipChildren();
continue;
}
try {
// Note: must handle null explicitly here; value deserializers won't
Object value;
if (t == JsonToken.VALUE_NULL) {
value = valueDes.getNullValue(ctxt);
} else if (typeDeser == null) {
value = valueDes.deserialize(p, ctxt);
} else {
value = valueDes.deserializeWithType(p, ctxt, typeDeser);
}
if (useObjectId) {
referringAccumulator.put(key, value);
} else {
result.put(key, value);
}
} catch (UnresolvedForwardReference reference) {
handleUnresolvedReference(p, referringAccumulator, key, reference);
} catch (Exception e) {
wrapAndThrow(e, result, key);
}
}
// 23-Mar-2015, tatu: TODO: verify we got END_OBJECT?
}
@SuppressWarnings("unchecked")
public Map<Object,Object> _deserializeUsingCreator(JsonParser p, DeserializationContext ctxt) throws IOException
{
final PropertyBasedCreator creator = _propertyBasedCreator;
// null -> no ObjectIdReader for Maps (yet?)
PropertyValueBuffer buffer = creator.startBuilding(p, ctxt, null);
final JsonDeserializer<Object> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
String key;
if (p.isExpectedStartObjectToken
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.impl;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.introspect.*;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.Annotations;
/**
* This concrete sub-class implements property that is set
* using regular "setter" method.
*/
public final class MethodProperty
extends SettableBeanProperty
{
private static final long serialVersionUID = 1;
protected final AnnotatedMethod _annotated;
/**
* Setter method for modifying property value; used for
* "regular" method-accessible properties.
*/
protected final transient Method _setter;
public MethodProperty(BeanPropertyDefinition propDef,
JavaType type, TypeDeserializer typeDeser,
Annotations contextAnnotations, AnnotatedMethod method)
{
super(propDef, type, typeDeser, contextAnnotations);
_annotated = method;
_setter = method.getAnnotated();
}
protected MethodProperty(MethodProperty src, JsonDeserializer<?> deser) {
super(src, deser);
_annotated = src._annotated;
_setter = src._setter;
}
protected MethodProperty(MethodProperty src, PropertyName newName) {
super(src, newName);
_annotated = src._annotated;
_setter = src._setter;
}
/**
* Constructor used for JDK Serialization when reading persisted object
*/
protected MethodProperty(MethodProperty src, Method m) {
super(src);
_annotated = src._annotated;
_setter = m;
}
@Override
public MethodProperty withName(PropertyName newName) {
return new MethodProperty(this, newName);
}
@Override
public MethodProperty withValueDeserializer(JsonDeserializer<?> deser) {
return new MethodProperty(this, deser);
}
@Override
public void fixAccess(DeserializationConfig config) {
_annotated.fixAccess(
config.isEnabled(MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS));
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> _buildMethod = src._buildMethod;
}
protected BuilderBasedDeserializer(BuilderBasedDeserializer src, NameTransformer unwrapper) {
super(src, unwrapper);
_buildMethod = src._buildMethod;
}
public BuilderBasedDeserializer(BuilderBasedDeserializer src, ObjectIdReader oir) {
super(src, oir);
_buildMethod = src._buildMethod;
}
public BuilderBasedDeserializer(BuilderBasedDeserializer src, Set<String> ignorableProps) {
super(src, ignorableProps);
_buildMethod = src._buildMethod;
}
public BuilderBasedDeserializer(BuilderBasedDeserializer src, BeanPropertyMap props) {
super(src, props);
_buildMethod = src._buildMethod;
}
@Override
public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper)
{
/* main thing really is to just enforce ignoring of unknown
* properties; since there may be multiple unwrapped values
* and properties for all may be interleaved...
*/
return new BuilderBasedDeserializer(this, unwrapper);
}
@Override
public BeanDeserializerBase withObjectIdReader(ObjectIdReader oir) {
return new BuilderBasedDeserializer(this, oir);
}
@Override
public BeanDeserializerBase withIgnorableProperties(Set<String> ignorableProps) {
return new BuilderBasedDeserializer(this, ignorableProps);
}
@Override
public BeanDeserializerBase withBeanProperties(BeanPropertyMap props) {
return new BuilderBasedDeserializer(this, props);
}
@Override
protected BeanDeserializerBase asArrayDeserializer() {
SettableBeanProperty[] props = _beanProperties.getPropertiesInInsertionOrder();
return new BeanAsArrayBuilderDeserializer(this, props, _buildMethod);
}
/*
/**********************************************************
/* JsonDeserializer implementation
/**********************************************************
*/
protected final Object finishBuild(DeserializationContext ctxt, Object builder)
throws IOException
{
// As per [databind#777], allow returning builder itself
if (null == _buildMethod) {
return builder;
}
try {
return _buildMethod.getMember().invoke(builder);
} catch (Exception e) {
return wrapInstantiationProblem(e, ctxt);
}
}
/**
* Main deserialization method for bean-based objects (POJOs).
*/
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.impl;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
import com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.Annotations;
/**
* This concrete sub-class implements Collection or Map property that is
* indirectly by getting the property value and directly modifying it.
*/
public final class SetterlessProperty
extends SettableBeanProperty
{
private static final long serialVersionUID = 1L;
protected final AnnotatedMethod _annotated;
/**
* Get method for accessing property value used to access property
* (of Collection or Map type) to modify.
*/
protected final Method _getter;
public SetterlessProperty(BeanPropertyDefinition propDef, JavaType type,
TypeDeserializer typeDeser, Annotations contextAnnotations, AnnotatedMethod method)
{
super(propDef, type, typeDeser, contextAnnotations);
_annotated = method;
_getter = method.getAnnotated();
}
protected SetterlessProperty(SetterlessProperty src, JsonDeserializer<?> deser) {
super(src, deser);
_annotated = src._annotated;
_getter = src._getter;
}
protected SetterlessProperty(SetterlessProperty src, PropertyName newName) {
super(src, newName);
_annotated = src._annotated;
_getter = src._getter;
}
@Override
public SetterlessProperty withName(PropertyName newName) {
return new SetterlessProperty(this, newName);
}
@Override
public SetterlessProperty withValueDeserializer(JsonDeserializer<?> deser) {
return new SetterlessProperty(this, deser);
}
@Override
public void fixAccess(DeserializationConfig config) {
_annotated.fixAccess(
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.impl.ObjectIdReader;
import com.fasterxml.jackson.databind.deser.impl.ReadableObjectId;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
/**
* Deserializer only used for abstract types used as placeholders during polymorphic
* type handling deserialization. If so, there is no real deserializer associated
* with nominal type, just {@link TypeDeserializer}; and any calls that do not
* pass such resolver will result in an error.
*/
public class AbstractDeserializer
extends JsonDeserializer<Object>
implements java.io.Serializable
{
private static final long serialVersionUID = 1L;
protected final JavaType _baseType;
protected final ObjectIdReader _objectIdReader;
protected final Map<String, SettableBeanProperty> _backRefProperties;
// support for "native" types, which require special care:
protected final boolean _acceptString;
protected final boolean _acceptBoolean;
protected final boolean _acceptInt;
protected final boolean _acceptDouble;
public AbstractDeserializer(BeanDeserializerBuilder builder,
BeanDescription beanDesc, Map<String, SettableBeanProperty> backRefProps)
{
_baseType = beanDesc.getType();
_objectIdReader = builder.getObjectIdReader();
_backRefProperties = backRefProps;
Class<?> cls = _baseType.getRawClass();
_acceptString = cls.isAssignableFrom(String.class);
_acceptBoolean = (cls == Boolean.TYPE) || cls.isAssignableFrom(Boolean.class);
_acceptInt = (cls == Integer.TYPE) || cls.isAssignableFrom(Integer.class);
_acceptDouble = (cls == Double.TYPE) || cls.isAssignableFrom(Double.class);
}
protected AbstractDeserializer(BeanDescription beanDesc)
{
_baseType = beanDesc.getType();
_objectIdReader = null;
_backRefProperties = null;
Class<?> cls = _baseType.getRawClass();
_acceptString = cls.isAssignableFrom(String.class);
_acceptBoolean = (cls == Boolean.TYPE) || cls.isAssignableFrom(Boolean
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>context.reportMappingException("Missing creator property '%s' (index %d); DeserializationFeature.FAIL_ON_MISSING_CREATOR_PROPERTIES enabled",
prop.getName(), prop.getCreatorIndex());
}
// Third: default value
JsonDeserializer<Object> deser = prop.getValueDeserializer();
return deser.getNullValue(_context);
}
/*
/**********************************************************
/* Other methods
/**********************************************************
*/
/**
* Helper method called to see if given non-creator property is the "id property";
* and if so, handle appropriately.
*
* @since 2.1
*/
public boolean readIdProperty(String propName) throws IOException
{
if ((_objectIdReader != null) && propName.equals(_objectIdReader.propertyName.getSimpleName())) {
_idValue = _objectIdReader.readObjectReference(_parser, _context);
return true;
}
return false;
}
/**
* Helper method called to handle Object Id value collected earlier, if any
*/
public Object handleIdValue(final DeserializationContext ctxt, Object bean) throws IOException
{
if (_objectIdReader != null) {
if (_idValue != null) {
ReadableObjectId roid = ctxt.findObjectId(_idValue, _objectIdReader.generator, _objectIdReader.resolver);
roid.bindItem(bean);
// also: may need to set a property value as well
SettableBeanProperty idProp = _objectIdReader.idProperty;
if (idProp != null) {
return idProp.setAndReturn(bean, _idValue);
}
} else {
// 07-Jun-2016, tatu: Trying to improve error messaging here...
ctxt.reportUnresolvedObjectId(_objectIdReader, bean);
}
}
return bean;
}
protected PropertyValue buffered() { return _buffered; }
public boolean isComplete() { return _paramsNeeded <= 0; }
/**
* @return True if we have received all creator parameters
*
* @since 2.6
*/
public boolean assignParameter(SettableBeanProperty prop, Object value)
{
final int ix = prop.getCreatorIndex();
_creatorParameters[ix] = value;
if (_paramsSeenBig == null) {
int old = _paramsSeen;
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Values(enumType, enumValues, names);
return names;
}
@Override
public Enum<?> findDefaultEnumValue(Class<Enum<?>> enumCls) {
Enum<?> en = _primary.findDefaultEnumValue(enumCls);
return (en == null) ? _secondary.findDefaultEnumValue(enumCls) : en;
}
// // // Deserialization: general annotations
@Override
public Object findDeserializer(Annotated am) {
Object r = _primary.findDeserializer(am);
return _isExplicitClassOrOb(r, JsonDeserializer.None.class)
? r : _secondary.findDeserializer(am);
}
@Override
public Object findKeyDeserializer(Annotated am) {
Object r = _primary.findKeyDeserializer(am);
return _isExplicitClassOrOb(r, KeyDeserializer.None.class)
? r : _secondary.findKeyDeserializer(am);
}
@Override
public Object findContentDeserializer(Annotated am) {
Object r = _primary.findContentDeserializer(am);
return _isExplicitClassOrOb(r, JsonDeserializer.None.class)
? r : _secondary.findContentDeserializer(am);
}
@Override
public Object findDeserializationConverter(Annotated a) {
Object ob = _primary.findDeserializationConverter(a);
return (ob == null) ? _secondary.findDeserializationConverter(a) : ob;
}
@Override
public Object findDeserializationContentConverter(AnnotatedMember a) {
Object ob = _primary.findDeserializationContentConverter(a);
return (ob == null) ? _secondary.findDeserializationContentConverter(a) : ob;
}
// // // Deserialization: type refinements
// since 2.7
@Override
public JavaType refineDeserializationType(MapperConfig<?> config,
Annotated a, JavaType baseType) throws JsonMappingException
{
JavaType t = _secondary.refineDeserializationType(config, a, baseType);
return _primary.refineDeserializationType(config, a, t);
}
@Override
@Deprecated
public Class<?> findDeserializationType(Annotated am, JavaType baseType) {
Class<?> r = _primary.findDeserializationType(am, baseType);
return (r != null) ? r : _secondary.findDeserializationType(am,
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.type.*;
/**
* Interface that defines API for simple extensions that can provide additional deserializers
* for various types. Access is by a single callback method; instance is to either return
* a configured {@link JsonDeserializer} for specified type, or null to indicate that it
* does not support handling of the type. In latter case, further calls can be made
* for other providers; in former case returned deserializer is used for handling of
* instances of specified type.
*<p>
* It is <b>strongly recommended</b> that implementations always extend {@link Deserializers.Base}
* and NOT just implement {@link Deserializers}.
*/
public interface Deserializers
{
// // // Scalar types first:
/**
* Method called to locate deserializer for specified {@link java.lang.Enum} type.
*
* @param type Type of {@link java.lang.Enum} instances to deserialize
* @param config Configuration in effect
* @param beanDesc Definition of the enumeration type that contains class annotations and
* other information typically needed for building deserializers
*
* @return Deserializer to use for the type; or null if this provider does not know how to construct it
*/
public JsonDeserializer<?> findEnumDeserializer(Class<?> type,
DeserializationConfig config, BeanDescription beanDesc)
throws JsonMappingException;
/**
* Method called to locate deserializer for specified JSON tree node type.
*
* @param nodeType Specific type of JSON tree nodes to deserialize
* (subtype of {@link com.fasterxml.jackson.databind.JsonNode})
* @param config Configuration in effect
*
* @return Deserializer to use for the type; or null if this provider does not know how to construct it
*/
public JsonDeserializer<?> findTreeNodeDeserializer(Class<? extends JsonNode> nodeType,
DeserializationConfig config, BeanDescription beanDesc)
throws JsonMappingException;
/**
* Method called to locate deserializer for specified value type which does not belong to any other
* category (not an Enum, Collection, Map, Array, reference value or tree node)
*
* @param
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> type Bean type to deserialize
* @param config Configuration in effect
* @param beanDesc Definition of the enumeration type that contains class annotations and
* other information typically needed for building deserializers
*
* @return Deserializer to use for the type; or null if this provider does not know how to construct it
*/
public JsonDeserializer<?> findBeanDeserializer(JavaType type,
DeserializationConfig config, BeanDescription beanDesc)
throws JsonMappingException;
// // // Then container types
/**
* Method called to locate deserializer for value that is of referential
* type,
*
* @param refType Specific referential type to deserialize
* @param config Configuration in effect
* @param beanDesc Definition of the reference type that contains class annotations and
* other information typically needed for building deserializers
* @param contentTypeDeserializer Possible type deserializer for referenced value
* @param contentDeserializer Value deserializer to use for referenced value, if indicated
* by property annotation
*
* @return Deserializer to use for the type; or null if this provider does not know how to construct it
*
* @since 2.7
*/
public JsonDeserializer<?> findReferenceDeserializer(ReferenceType refType,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer contentTypeDeserializer, JsonDeserializer<?> contentDeserializer)
throws JsonMappingException;
/**
* Method called to locate serializer for specified array type.
*<p>
* Deserializer for element type may be passed, if configured explicitly at higher level (by
* annotations, typically), but usually are not.
* Type deserializer for element is passed if one is needed based on contextual information
* (annotations on declared element class; or on field or method type is associated with).
*
* @param type Type of array instances to deserialize
* @param config Configuration in effect
* @param beanDesc Definition of the enumeration type that contains class annotations and
* other information typically needed for building deserializers
* @param elementTypeDeserializer If element type needs polymorphic type handling, this is
* the type information deserializer to use; should usually be used as is when constructing
* array deserializer.
* @param elementDeserializer Deserializer to use for elements, if explicitly defined (by using
* annotations, for exmple). May be null, in which case it should be
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> resolved here (or using
* {@link ResolvableDeserializer} callback)
*
* @return Deserializer to use for the type; or null if this provider does not know how to construct it
*/
public JsonDeserializer<?> findArrayDeserializer(ArrayType type,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException;
/**
* Method called to locate serializer for specified {@link java.util.Collection} (List, Set etc) type.
*<p>
* Deserializer for element type may be passed, if configured explicitly at higher level (by
* annotations, typically), but usually are not.
* Type deserializer for element is passed if one is needed based on contextual information
* (annotations on declared element class; or on field or method type is associated with).
*
* @param type Type of collection instances to deserialize
* @param config Configuration in effect
* @param beanDesc Definition of the enumeration type that contains class annotations and
* other information typically needed for building deserializers
* @param elementTypeDeserializer If element type needs polymorphic type handling, this is
* the type information deserializer to use; should usually be used as is when constructing
* array deserializer.
* @param elementDeserializer Deserializer to use for elements, if explicitly defined (by using
* annotations, for exmple). May be null, in which case it should be resolved here (or using
* {@link ResolvableDeserializer} callback)
*
* @return Deserializer to use for the type; or null if this provider does not know how to construct it
*/
public JsonDeserializer<?> findCollectionDeserializer(CollectionType type,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException;
/**
* Method called to locate serializer for specified
* "Collection-like" type (one that acts
* like {@link java.util.Collection} but does not implement it).
*<p>
* Deserializer for element type may be passed, if configured explicitly at higher level (by
* annotations, typically), but usually are not.
* Type deserializer for element is passed if one is needed based on contextual information
* (annotations on declared element class; or on field or
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> method type is associated with).
*
* @param type Type of instances to deserialize
* @param config Configuration in effect
* @param beanDesc Definition of the enumeration type that contains class annotations and
* other information typically needed for building deserializers
* @param elementTypeDeserializer If element type needs polymorphic type handling, this is
* the type information deserializer to use; should usually be used as is when constructing
* array deserializer.
* @param elementDeserializer Deserializer to use for elements, if explicitly defined (by using
* annotations, for exmple). May be null, in which case it should be resolved here (or using
* {@link ResolvableDeserializer} callback)
*
* @return Deserializer to use for the type; or null if this provider does not know how to construct it
*/
public JsonDeserializer<?> findCollectionLikeDeserializer(CollectionLikeType type,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException;
/**
* Method called to locate deserializer for specified {@link java.util.Map} type.
*<p>
* Deserializer for element type may be passed, if configured explicitly at higher level (by
* annotations, typically), but usually are not.
* Type deserializer for element is passed if one is needed based on contextual information
* (annotations on declared element class; or on field or method type is associated with).
*<p>
* Similarly, a {@link KeyDeserializer} may be passed, but this is only done if there is
* a specific configuration override (annotations) to indicate instance to use.
* Otherwise null is passed, and key deserializer needs to be obtained later during
* resolution (using {@link ResolvableDeserializer#resolve}).
*
* @param type Type of {@link java.util.Map} instances to deserialize
* @param config Configuration in effect
* @param beanDesc Definition of the enumeration type that contains class annotations and
* other information typically needed for building deserializers
* @param keyDeserializer Key deserializer use, if it is defined via annotations or other configuration;
* null if default key deserializer for key type can be used.
* @param elementTypeDeserializer If element type needs polymorphic type handling, this is
* the type information de
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>serializer to use; should usually be used as is when constructing
* array deserializer.
* @param elementDeserializer Deserializer to use for elements, if explicitly defined (by using
* annotations, for exmple). May be null, in which case it should be resolved here (or using
* {@link ResolvableDeserializer} callback)
*
* @return Deserializer to use for the type; or null if this provider does not know how to construct it
*/
public JsonDeserializer<?> findMapDeserializer(MapType type,
DeserializationConfig config, BeanDescription beanDesc,
KeyDeserializer keyDeserializer,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException;
/**
* Method called to locate serializer for specified
* "Map-like" type (one that acts
* like {@link java.util.Map} but does not implement it).
*<p>
* Deserializer for element type may be passed, if configured explicitly at higher level (by
* annotations, typically), but usually are not.
* Type deserializer for element is passed if one is needed based on contextual information
* (annotations on declared element class; or on field or method type is associated with).
*<p>
* Similarly, a {@link KeyDeserializer} may be passed, but this is only done if there is
* a specific configuration override (annotations) to indicate instance to use.
* Otherwise null is passed, and key deserializer needs to be obtained later during
* resolution (using {@link ResolvableDeserializer#resolve}).
*
* @param type Type of {@link java.util.Map} instances to deserialize
* @param config Configuration in effect
* @param beanDesc Definition of the enumeration type that contains class annotations and
* other information typically needed for building deserializers
* @param keyDeserializer Key deserializer use, if it is defined via annotations or other configuration;
* null if default key deserializer for key type can be used.
* @param elementTypeDeserializer If element type needs polymorphic type handling, this is
* the type information deserializer to use; should usually be used as is when constructing
* array deserializer.
* @param elementDeserializer Deserializer to use for elements, if explicitly defined (by using
* annotations, for exmple). May be null, in which case it
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> should be resolved here (or using
* {@link ResolvableDeserializer} callback)
*
* @return Deserializer to use for the type; or null if this provider does not know how to construct it
*/
public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type,
DeserializationConfig config, BeanDescription beanDesc,
KeyDeserializer keyDeserializer,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException;
/*
/**********************************************************
/* Helper classes
/**********************************************************
*/
/**
* Basic {@link Deserializers} implementation that implements all methods but provides
* no deserializers. Its main purpose is to serve as a base class so that
* sub-classes only need to override methods they need, as most of the time some
* of methods are not needed (especially enumeration and array deserializers are
* very rarely overridden).
*/
public static class Base implements Deserializers
{
@Override
public JsonDeserializer<?> findEnumDeserializer(Class<?> type,
DeserializationConfig config, BeanDescription beanDesc)
throws JsonMappingException
{
return null;
}
@Override
public JsonDeserializer<?> findTreeNodeDeserializer(Class<? extends JsonNode> nodeType,
DeserializationConfig config, BeanDescription beanDesc)
throws JsonMappingException
{
return null;
}
@Override // since 2.7
public JsonDeserializer<?> findReferenceDeserializer(ReferenceType refType,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer contentTypeDeserializer, JsonDeserializer<?> contentDeserializer)
throws JsonMappingException {
// 21-Oct-2015, tatu: For backwards compatibility, let's delegate to "bean" variant,
// for 2.7 -- remove work-around from 2.8 or later
return findBeanDeserializer(refType, config, beanDesc);
}
@Override
public JsonDeserializer<?> findBeanDeserializer(JavaType type,
DeserializationConfig config, BeanDescription beanDesc)
throws JsonMappingException
{
return null;
}
@Override
public JsonDeserializer<?> findArrayDeserializer(ArrayType type,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException
{
return null;
}
@Override
public JsonDeserializer<?> findCollectionDeserializer(CollectionType
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> type,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException
{
return null;
}
@Override
public JsonDeserializer<?> findCollectionLikeDeserializer(CollectionLikeType type,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException
{
return null;
}
@Override
public JsonDeserializer<?> findMapDeserializer(MapType type,
DeserializationConfig config, BeanDescription beanDesc,
KeyDeserializer keyDeserializer,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException
{
return null;
}
@Override
public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type,
DeserializationConfig config, BeanDescription beanDesc,
KeyDeserializer keyDeserializer,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException
{
return null;
}
}
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.impl;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.introspect.*;
import com.fasterxml.jackson.databind.util.ClassUtil;
/**
* This sub-class is used to handle special case of value being a
* non-static inner class. If so, we will have to use a special
* alternative for default constructor; but otherwise can delegate
* to regular implementation.
*/
public final class InnerClassProperty
extends SettableBeanProperty
{
private static final long serialVersionUID = 1L;
/**
* Actual property that we use after value construction.
*/
protected final SettableBeanProperty _delegate;
/**
* Constructor used when deserializing this property.
* Transient since there is no need to persist; only needed during
* construction of objects.
*/
final protected transient Constructor<?> _creator;
/**
* Serializable version of single-arg constructor we use for value instantiation.
*/
protected AnnotatedConstructor _annotated;
public InnerClassProperty(SettableBeanProperty delegate,
Constructor<?> ctor)
{
super(delegate);
_delegate = delegate;
_creator = ctor;
}
/**
* Constructor used with JDK Serialization; needed to handle transient
* Constructor, wrap/unwrap in/out-of Annotated variant.
*/
protected InnerClassProperty(InnerClassProperty src, AnnotatedConstructor ann)
{
super(src);
_delegate = src._delegate;
_annotated = ann;
_creator = (_annotated == null) ? null : _annotated.getAnnotated();
if (_creator == null) {
throw new IllegalArgumentException("Missing constructor (broken JDK (de)serialization?)");
}
}
protected InnerClassProperty(InnerClassProperty src, JsonDeserializer<?> deser)
{
super(src, deser);
_delegate = src._delegate.withValueDeserializer(deser);
_creator = src._creator;
}
protected InnerClassProperty(InnerClassProperty src, PropertyName newName) {
super(src,
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> newName);
_delegate = src._delegate.withName(newName);
_creator = src._creator;
}
@Override
public InnerClassProperty withName(PropertyName newName) {
return new InnerClassProperty(this, newName);
}
@Override
public InnerClassProperty withValueDeserializer(JsonDeserializer<?> deser) {
return new InnerClassProperty(this, deser);
}
@Override
public void fixAccess(DeserializationConfig config) {
_delegate.fixAccess(config);
}
// // // BeanProperty impl
@Override
public <A extends Annotation> A getAnnotation(Class<A> acls) {
return _delegate.getAnnotation(acls);
}
@Override public AnnotatedMember getMember() { return _delegate.getMember(); }
/*
/**********************************************************
/* Deserialization methods
/**********************************************************
*/
@Override
public void deserializeAndSet(JsonParser jp, DeserializationContext ctxt, Object bean)
throws IOException
{
JsonToken t = jp.getCurrentToken();
Object value;
if (t == JsonToken.VALUE_NULL) {
value = _valueDeserializer.getNullValue(ctxt);
} else if (_valueTypeDeserializer != null) {
value = _valueDeserializer.deserializeWithType(jp, ctxt, _valueTypeDeserializer);
} else { // the usual case
try {
value = _creator.newInstance(bean);
} catch (Exception e) {
ClassUtil.unwrapAndThrowAsIAE(e, "Failed to instantiate class "+_creator.getDeclaringClass().getName()+", problem: "+e.getMessage());
value = null;
}
_valueDeserializer.deserialize(jp, ctxt, value);
}
set(bean, value);
}
@Override
public Object deserializeSetAndReturn(JsonParser jp,
DeserializationContext ctxt, Object instance)
throws IOException
{
return setAndReturn(instance, deserialize(jp, ctxt));
}
@Override
public final void set(Object instance, Object value) throws IOException {
_delegate.set(instance, value);
}
@Override
public Object setAndReturn(Object instance, Object value) throws IOException {
return _delegate.setAndReturn(instance, value);
}
/*
/**********************************************************
/* JDK serialization handling
/**********************************************************
*/
// When
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.impl;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
/**
* A deserializer that stores an {@link Error} caught during constructing
* of the deserializer, which needs to be deferred and only during actual
* attempt to deserialize a value of given type.
* Note that null and empty values can be deserialized without error.
*
* @since 2.9 Note: prior to this version was named <code>NoClassDefFoundDeserializer</code>
*/
public class ErrorThrowingDeserializer extends JsonDeserializer<Object>
{
private final Error _cause;
public ErrorThrowingDeserializer(NoClassDefFoundError cause) {
_cause = cause;
}
@Override
public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
throw _cause;
}
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.deser.*;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
/**
* Basic serializer that can take JSON "Object" structure and
* construct a {@link java.util.Map} instance, with typed contents.
*<p>
* Note: for untyped content (one indicated by passing Object.class
* as the type), {@link UntypedObjectDeserializer} is used instead.
* It can also construct {@link java.util.Map}s, but not with specific
* POJO types, only other containers and primitives/wrappers.
*/
@JacksonStdImpl
public class MapEntryDeserializer
extends ContainerDeserializerBase<Map.Entry<Object,Object>>
implements ContextualDeserializer
{
private static final long serialVersionUID = 1;
// // Configuration: typing, deserializers
protected final JavaType _type;
/**
* Key deserializer to use; either passed via constructor
* (when indicated by annotations), or resolved when
* {@link #createContextual} is called;
*/
protected final KeyDeserializer _keyDeserializer;
/**
* Value deserializer.
*/
protected final JsonDeserializer<Object> _valueDeserializer;
/**
* If value instances have polymorphic type information, this
* is the type deserializer that can handle it
*/
protected final TypeDeserializer _valueTypeDeserializer;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
public MapEntryDeserializer(JavaType type,
KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser,
TypeDeserializer valueTypeDeser)
{
super(type);
if (type.containedTypeCount() != 2) { // sanity check
throw new IllegalArgumentException("Missing generic type information for "+type);
}
_type = type;
_keyDeserializer = keyDeser;
_valueDeserializer = valueDeser;
_valueTypeDeserializer = valueTypeDeser;
}
/**
* Copy-constructor that can be used by sub-classes
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> to allow
* copy-on-write styling copying of settings of an existing instance.
*/
protected MapEntryDeserializer(MapEntryDeserializer src)
{
super(src._type);
_type = src._type;
_keyDeserializer = src._keyDeserializer;
_valueDeserializer = src._valueDeserializer;
_valueTypeDeserializer = src._valueTypeDeserializer;
}
protected MapEntryDeserializer(MapEntryDeserializer src,
KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser,
TypeDeserializer valueTypeDeser)
{
super(src._type);
_type = src._type;
_keyDeserializer = keyDeser;
_valueDeserializer = valueDeser;
_valueTypeDeserializer = valueTypeDeser;
}
/**
* Fluent factory method used to create a copy with slightly
* different settings. When sub-classing, MUST be overridden.
*/
@SuppressWarnings("unchecked")
protected MapEntryDeserializer withResolved(KeyDeserializer keyDeser,
TypeDeserializer valueTypeDeser, JsonDeserializer<?> valueDeser)
{
if ((_keyDeserializer == keyDeser) && (_valueDeserializer == valueDeser)
&& (_valueTypeDeserializer == valueTypeDeser)) {
return this;
}
return new MapEntryDeserializer(this,
keyDeser, (JsonDeserializer<Object>) valueDeser, valueTypeDeser);
}
/*
/**********************************************************
/* Validation, post-processing (ResolvableDeserializer)
/**********************************************************
*/
/**
* Method called to finalize setup of this deserializer,
* when it is known for which property deserializer is needed for.
*/
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
KeyDeserializer kd = _keyDeserializer;
if (kd == null) {
kd = ctxt.findKeyDeserializer(_type.containedType(0), property);
} else {
if (kd instanceof ContextualKeyDeserializer) {
kd = ((ContextualKeyDeserializer) kd).createContextual(ctxt, property);
}
}
JsonDeserializer<?> vd = _valueDeserializer;
vd = findConvertingContentDeserializer(ctxt, property, vd);
JavaType contentType = _type.containedType(1);
if (vd == null) {
vd = ctxt.find
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>ContextualValueDeserializer(contentType, property);
} else { // if directly assigned, probably not yet contextual, so:
vd = ctxt.handleSecondaryContextualization(vd, property, contentType);
}
TypeDeserializer vtd = _valueTypeDeserializer;
if (vtd != null) {
vtd = vtd.forProperty(property);
}
return withResolved(kd, vtd, vd);
}
/*
/**********************************************************
/* ContainerDeserializerBase API
/**********************************************************
*/
@Override
public JavaType getContentType() {
return _type.containedType(1);
}
@Override
public JsonDeserializer<Object> getContentDeserializer() {
return _valueDeserializer;
}
/*
/**********************************************************
/* JsonDeserializer API
/**********************************************************
*/
@SuppressWarnings("unchecked")
@Override
public Map.Entry<Object,Object> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException
{
// Ok: must point to START_OBJECT, FIELD_NAME or END_OBJECT
JsonToken t = p.getCurrentToken();
if (t != JsonToken.START_OBJECT && t != JsonToken.FIELD_NAME && t != JsonToken.END_OBJECT) {
// String may be ok however:
// slightly redundant (since String was passed above), but
return _deserializeFromEmpty(p, ctxt);
}
if (t == JsonToken.START_OBJECT) {
t = p.nextToken();
}
if (t != JsonToken.FIELD_NAME) {
if (t == JsonToken.END_OBJECT) {
ctxt.reportMappingException("Can not deserialize a Map.Entry out of empty JSON Object");
return null;
}
return (Map.Entry<Object,Object>) ctxt.handleUnexpectedToken(handledType(), p);
}
final KeyDeserializer keyDes = _keyDeserializer;
final JsonDeserializer<Object> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
final String keyStr = p.getCurrentName();
Object key = keyDes.deserializeKey(keyStr, ctxt);
Object value = null;
// And then the value...
t = p.nextToken();
try {
// Note: must handle null explicitly here; value deserializers won't
if (t == JsonToken.VALUE_NULL)
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> config)
{
if (_factoryConfig == config) {
return this;
}
/* 22-Nov-2010, tatu: Handling of subtypes is tricky if we do immutable-with-copy-ctor;
* and we pretty much have to here either choose between losing subtype instance
* when registering additional deserializers, or losing deserializers.
* Instead, let's actually just throw an error if this method is called when subtype
* has not properly overridden this method; this to indicate problem as soon as possible.
*/
if (getClass() != BeanDeserializerFactory.class) {
throw new IllegalStateException("Subtype of BeanDeserializerFactory ("+getClass().getName()
+") has not properly overridden method 'withAdditionalDeserializers': can not instantiate subtype with "
+"additional deserializer definitions");
}
return new BeanDeserializerFactory(config);
}
/*
/**********************************************************
/* DeserializerFactory API implementation
/**********************************************************
*/
/**
* Method that {@link DeserializerCache}s call to create a new
* deserializer for types other than Collections, Maps, arrays and
* enums.
*/
@Override
public JsonDeserializer<Object> createBeanDeserializer(DeserializationContext ctxt,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
// We may also have custom overrides:
JsonDeserializer<Object> custom = _findCustomBeanDeserializer(type, config, beanDesc);
if (custom != null) {
return custom;
}
/* One more thing to check: do we have an exception type
* (Throwable or its sub-classes)? If so, need slightly
* different handling.
*/
if (type.isThrowable()) {
return buildThrowableDeserializer(ctxt, type, beanDesc);
}
/* Or, for abstract types, may have alternate means for resolution
* (defaulting, materialization)
*/
// 29-Nov-2015, tatu: Also, filter out calls to primitive types, they are
// not something we could materialize anything for
if (type.isAbstract() && !type.isPrimitive() && !type.isEnumType()) {
// Let's make it possible to materialize abstract types.
JavaType concreteType = materializeAbstract
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Type(ctxt, type, beanDesc);
if (concreteType != null) {
/* important: introspect actual implementation (abstract class or
* interface doesn't have constructors, for one)
*/
beanDesc = config.introspect(concreteType);
return buildBeanDeserializer(ctxt, concreteType, beanDesc);
}
}
// Otherwise, may want to check handlers for standard types, from superclass:
@SuppressWarnings("unchecked")
JsonDeserializer<Object> deser = (JsonDeserializer<Object>) findStdDeserializer(ctxt, type, beanDesc);
if (deser != null) {
return deser;
}
// Otherwise: could the class be a Bean class? If not, bail out
if (!isPotentialBeanType(type.getRawClass())) {
return null;
}
// Use generic bean introspection to build deserializer
return buildBeanDeserializer(ctxt, type, beanDesc);
}
@Override
public JsonDeserializer<Object> createBuilderBasedDeserializer(
DeserializationContext ctxt, JavaType valueType, BeanDescription beanDesc,
Class<?> builderClass)
throws JsonMappingException
{
// First: need a BeanDescription for builder class
JavaType builderType = ctxt.constructType(builderClass);
BeanDescription builderDesc = ctxt.getConfig().introspectForBuilder(builderType);
return buildBuilderBasedDeserializer(ctxt, valueType, builderDesc);
}
/**
* Method called by {@link BeanDeserializerFactory} to see if there might be a standard
* deserializer registered for given type.
*/
protected JsonDeserializer<?> findStdDeserializer(DeserializationContext ctxt,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException
{
// note: we do NOT check for custom deserializers here, caller has already
// done that
JsonDeserializer<?> deser = findDefaultDeserializer(ctxt, type, beanDesc);
// Also: better ensure these are post-processable?
if (deser != null) {
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deser = mod.modifyDeserializer(ctxt.getConfig(), beanDesc, deser);
}
}
}
return deser;
}
protected JavaType materializeAbstractType(DeserializationContext ctxt,
JavaType type, BeanDescription beanDesc)
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
throws JsonMappingException
{
// May have multiple resolvers, call in precedence order until one returns non-null
for (AbstractTypeResolver r : _factoryConfig.abstractTypeResolvers()) {
JavaType concrete = r.resolveAbstractType(ctxt.getConfig(), beanDesc);
if (concrete != null) {
return concrete;
}
}
return null;
}
/*
/**********************************************************
/* Public construction method beyond DeserializerFactory API:
/* can be called from outside as well as overridden by
/* sub-classes
/**********************************************************
*/
/**
* Method that is to actually build a bean deserializer instance.
* All basic sanity checks have been done to know that what we have
* may be a valid bean type, and that there are no default simple
* deserializers.
*/
@SuppressWarnings("unchecked")
public JsonDeserializer<Object> buildBeanDeserializer(DeserializationContext ctxt,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException
{
// First: check what creators we can use, if any
ValueInstantiator valueInstantiator;
/* 04-Jun-2015, tatu: To work around [databind#636], need to catch the
* issue, defer; this seems like a reasonable good place for now.
* Note, however, that for non-Bean types (Collections, Maps) this
* probably won't work and needs to be added elsewhere.
*/
try {
valueInstantiator = findValueInstantiator(ctxt, beanDesc);
} catch (NoClassDefFoundError error) {
return new ErrorThrowingDeserializer(error);
}
BeanDeserializerBuilder builder = constructBeanDeserializerBuilder(ctxt, beanDesc);
builder.setValueInstantiator(valueInstantiator);
// And then setters for deserializing from JSON Object
addBeanProps(ctxt, beanDesc, builder);
addObjectIdReader(ctxt, beanDesc, builder);
// managed/back reference fields/setters need special handling... first part
addReferenceProperties(ctxt, beanDesc, builder);
addInjectables(ctxt, beanDesc, builder);
final DeserializationConfig config = ctxt.getConfig();
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
builder = mod.updateBuilder
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>(config, beanDesc, builder);
}
}
JsonDeserializer<?> deserializer;
/* 19-Mar-2012, tatu: This check used to be done earlier; but we have to defer
* it a bit to collect information on ObjectIdReader, for example.
*/
if (type.isAbstract() && !valueInstantiator.canInstantiate()) {
deserializer = builder.buildAbstract();
} else {
deserializer = builder.build();
}
// [JACKSON-440]: may have modifier(s) that wants to modify or replace serializer we just built:
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deserializer = mod.modifyDeserializer(config, beanDesc, deserializer);
}
}
return (JsonDeserializer<Object>) deserializer;
}
/**
* Method for constructing a bean deserializer that uses specified
* intermediate Builder for binding data, and construction of the
* value instance.
* Note that implementation is mostly copied from the regular
* BeanDeserializer build method.
*/
@SuppressWarnings("unchecked")
protected JsonDeserializer<Object> buildBuilderBasedDeserializer(
DeserializationContext ctxt, JavaType valueType, BeanDescription builderDesc)
throws JsonMappingException
{
// Creators, anyone? (to create builder itself)
ValueInstantiator valueInstantiator = findValueInstantiator(ctxt, builderDesc);
final DeserializationConfig config = ctxt.getConfig();
BeanDeserializerBuilder builder = constructBeanDeserializerBuilder(ctxt, builderDesc);
builder.setValueInstantiator(valueInstantiator);
// And then "with methods" for deserializing from JSON Object
addBeanProps(ctxt, builderDesc, builder);
addObjectIdReader(ctxt, builderDesc, builder);
// managed/back reference fields/setters need special handling... first part
addReferenceProperties(ctxt, builderDesc, builder);
addInjectables(ctxt, builderDesc, builder);
JsonPOJOBuilder.Value builderConfig = builderDesc.findPOJOBuilderConfig();
final String buildMethodName = (builderConfig == null) ?
"build" : builderConfig.buildMethodName;
// and lastly, find build method to use:
AnnotatedMethod buildMethod = builderDesc.findMethod(buildMethodName,
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> null);
if (buildMethod != null) { // note: can't yet throw error; may be given build method
if (config.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(buildMethod.getMember(), config.isEnabled(MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS));
}
}
builder.setPOJOBuilder(buildMethod, builderConfig);
// this may give us more information...
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
builder = mod.updateBuilder(config, builderDesc, builder);
}
}
JsonDeserializer<?> deserializer = builder.buildBuilderBased(
valueType, buildMethodName);
// [JACKSON-440]: may have modifier(s) that wants to modify or replace serializer we just built:
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deserializer = mod.modifyDeserializer(config, builderDesc, deserializer);
}
}
return (JsonDeserializer<Object>) deserializer;
}
protected void addObjectIdReader(DeserializationContext ctxt,
BeanDescription beanDesc, BeanDeserializerBuilder builder)
throws JsonMappingException
{
ObjectIdInfo objectIdInfo = beanDesc.getObjectIdInfo();
if (objectIdInfo == null) {
return;
}
Class<?> implClass = objectIdInfo.getGeneratorType();
JavaType idType;
SettableBeanProperty idProp;
ObjectIdGenerator<?> gen;
ObjectIdResolver resolver = ctxt.objectIdResolverInstance(beanDesc.getClassInfo(), objectIdInfo);
// Just one special case: Property-based generator is trickier
if (implClass == ObjectIdGenerators.PropertyGenerator.class) { // most special one, needs extra work
PropertyName propName = objectIdInfo.getPropertyName();
idProp = builder.findProperty(propName);
if (idProp == null) {
throw new IllegalArgumentException("Invalid Object Id definition for "
+beanDesc.getBeanClass().getName()+": can not find property with name '"+propName+"'");
}
idType = idProp.getType();
gen = new PropertyBasedObjectIdGenerator(objectIdInfo.getScope());
} else {
JavaType type = ctxt.constructType
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>(implClass);
idType = ctxt.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0];
idProp = null;
gen = ctxt.objectIdGeneratorInstance(beanDesc.getClassInfo(), objectIdInfo);
}
// also: unlike with value deserializers, let's just resolve one we need here
JsonDeserializer<?> deser = ctxt.findRootValueDeserializer(idType);
builder.setObjectIdReader(ObjectIdReader.construct(idType,
objectIdInfo.getPropertyName(), gen, deser, idProp, resolver));
}
@SuppressWarnings("unchecked")
public JsonDeserializer<Object> buildThrowableDeserializer(DeserializationContext ctxt,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
// first: construct like a regular bean deserializer...
BeanDeserializerBuilder builder = constructBeanDeserializerBuilder(ctxt, beanDesc);
builder.setValueInstantiator(findValueInstantiator(ctxt, beanDesc));
addBeanProps(ctxt, beanDesc, builder);
// (and assume there won't be any back references)
// But then let's decorate things a bit
/* To resolve [JACKSON-95], need to add "initCause" as setter
* for exceptions (sub-classes of Throwable).
*/
AnnotatedMethod am = beanDesc.findMethod("initCause", INIT_CAUSE_PARAMS);
if (am != null) { // should never be null
SimpleBeanPropertyDefinition propDef = SimpleBeanPropertyDefinition.construct(ctxt.getConfig(), am,
new PropertyName("cause"));
SettableBeanProperty prop = constructSettableProperty(ctxt, beanDesc, propDef,
am.getParameterType(0));
if (prop != null) {
/* 21-Aug-2011, tatus: We may actually have found 'cause' property
* to set... but let's replace it just in case,
* otherwise can end up with odd errors.
*/
builder.addOrReplaceProperty(prop, true);
}
}
// And also need to ignore "localizedMessage"
builder.addIgnorable("localizedMessage");
// Java 7 also added "getSuppressed", skip if we have such data:
builder.addIgnorable("suppressed");
/* As well as
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> "message": it will be passed via constructor,
* as there's no 'setMessage()' method
*/
builder.addIgnorable("message");
// update builder now that all information is in?
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
builder = mod.updateBuilder(config, beanDesc, builder);
}
}
JsonDeserializer<?> deserializer = builder.build();
/* At this point it ought to be a BeanDeserializer; if not, must assume
* it's some other thing that can handle deserialization ok...
*/
if (deserializer instanceof BeanDeserializer) {
deserializer = new ThrowableDeserializer((BeanDeserializer) deserializer);
}
// may have modifier(s) that wants to modify or replace serializer we just built:
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deserializer = mod.modifyDeserializer(config, beanDesc, deserializer);
}
}
return (JsonDeserializer<Object>) deserializer;
}
/*
/**********************************************************
/* Helper methods for Bean deserializer construction,
/* overridable by sub-classes
/**********************************************************
*/
/**
* Overridable method that constructs a {@link BeanDeserializerBuilder}
* which is used to accumulate information needed to create deserializer
* instance.
*/
protected BeanDeserializerBuilder constructBeanDeserializerBuilder(DeserializationContext ctxt,
BeanDescription beanDesc) {
return new BeanDeserializerBuilder(beanDesc, ctxt.getConfig());
}
/**
* Method called to figure out settable properties for the
* bean deserializer to use.
*<p>
* Note: designed to be overridable, and effort is made to keep interface
* similar between versions.
*/
protected void addBeanProps(DeserializationContext ctxt,
BeanDescription beanDesc, BeanDeserializerBuilder builder)
throws JsonMappingException
{
final SettableBeanProperty[] creatorProps =
builder.getValueInstantiator().getFromObjectArguments(ctxt.getConfig());
final boolean isConcrete = !beanDesc.getType().isAbstract();
// 01-May-2016, tatu: Which base type to use here gets tricky, since
// it may often make most sense to use general type
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>m.getName()),
m.getType(),
beanDesc.getClassAnnotations(), m, entry.getKey());
}
}
}
/**
* Method called to construct fallback {@link SettableAnyProperty}
* for handling unknown bean properties, given a method that
* has been designated as such setter.
*
* @param mutator Either 2-argument method (setter, with key and value), or Field
* that contains Map; either way accessor used for passing "any values"
*/
@SuppressWarnings("unchecked")
protected SettableAnyProperty constructAnySetter(DeserializationContext ctxt,
BeanDescription beanDesc, AnnotatedMember mutator)
throws JsonMappingException
{
//find the java type based on the annotated setter method or setter field
JavaType type = null;
if (mutator instanceof AnnotatedMethod) {
// we know it's a 2-arg method, second arg is the value
type = ((AnnotatedMethod) mutator).getParameterType(1);
} else if (mutator instanceof AnnotatedField) {
// get the type from the content type of the map object
type = ((AnnotatedField) mutator).getType().getContentType();
}
// First: various annotations on type itself, as well as type-overrides
// on accessor need to be resolved
type = resolveMemberAndTypeAnnotations(ctxt, mutator, type);
BeanProperty.Std prop = new BeanProperty.Std(PropertyName.construct(mutator.getName()),
type, null, beanDesc.getClassAnnotations(), mutator,
PropertyMetadata.STD_OPTIONAL);
// and then possible direct deserializer override on accessor
JsonDeserializer<Object> deser = findDeserializerFromAnnotation(ctxt, mutator);
if (deser == null) {
deser = type.getValueHandler();
}
if (deser != null) {
// As per [databind#462] need to ensure we contextualize deserializer before passing it on
deser = (JsonDeserializer<Object>) ctxt.handlePrimaryContextualization(deser, prop, type);
}
TypeDeserializer typeDeser = type.getTypeHandler();
return new SettableAnyProperty(prop, mutator, type, deser, typeDeser);
}
/**
* Method that will construct a regular bean property setter using
* the given setter method.
*
* @
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>return Property constructed, if any; or null to indicate that
* there should be no property based on given definitions.
*/
protected SettableBeanProperty constructSettableProperty(DeserializationContext ctxt,
BeanDescription beanDesc, BeanPropertyDefinition propDef,
JavaType propType0)
throws JsonMappingException
{
// need to ensure method is callable (for non-public)
AnnotatedMember mutator = propDef.getNonConstructorMutator();
// 08-Sep-2016, tatu: issues like [databind#1342] suggest something fishy
// going on; add sanity checks to try to pin down actual problem...
// Possibly passing creator parameter?
if (mutator == null) {
ctxt.reportBadPropertyDefinition(beanDesc, propDef, "No non-constructor mutator available");
}
JavaType type = resolveMemberAndTypeAnnotations(ctxt, mutator, propType0);
// Does the Method specify the deserializer to use? If so, let's use it.
TypeDeserializer typeDeser = type.getTypeHandler();
SettableBeanProperty prop;
if (mutator instanceof AnnotatedMethod) {
prop = new MethodProperty(propDef, type, typeDeser,
beanDesc.getClassAnnotations(), (AnnotatedMethod) mutator);
} else {
// 08-Sep-2016, tatu: wonder if we should verify it is `AnnotatedField` to be safe?
prop = new FieldProperty(propDef, type, typeDeser,
beanDesc.getClassAnnotations(), (AnnotatedField) mutator);
}
JsonDeserializer<?> deser = findDeserializerFromAnnotation(ctxt, mutator);
if (deser == null) {
deser = type.getValueHandler();
}
if (deser != null) {
deser = ctxt.handlePrimaryContextualization(deser, prop, type);
prop = prop.withValueDeserializer(deser);
}
// need to retain name of managed forward references:
AnnotationIntrospector.ReferenceProperty ref = propDef.findReferenceType();
if (ref != null && ref.isManagedReference()) {
prop.setManagedReferenceName(ref.getName());
}
ObjectIdInfo objectIdInfo = propDef.findObjectIdInfo();
if (objectIdInfo != null
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>){
prop.setObjectIdInfo(objectIdInfo);
}
return prop;
}
/**
* Method that will construct a regular bean property setter using
* the given setter method.
*/
protected SettableBeanProperty constructSetterlessProperty(DeserializationContext ctxt,
BeanDescription beanDesc, BeanPropertyDefinition propDef)
throws JsonMappingException
{
final AnnotatedMethod getter = propDef.getGetter();
JavaType type = resolveMemberAndTypeAnnotations(ctxt, getter, getter.getType());
TypeDeserializer typeDeser = type.getTypeHandler();
SettableBeanProperty prop = new SetterlessProperty(propDef, type, typeDeser,
beanDesc.getClassAnnotations(), getter);
JsonDeserializer<?> deser = findDeserializerFromAnnotation(ctxt, getter);
if (deser == null) {
deser = type.getValueHandler();
}
if (deser != null) {
deser = ctxt.handlePrimaryContextualization(deser, prop, type);
prop = prop.withValueDeserializer(deser);
}
return prop;
}
/*
/**********************************************************
/* Helper methods for Bean deserializer, other
/**********************************************************
*/
/**
* Helper method used to skip processing for types that we know
* can not be (i.e. are never consider to be) beans:
* things like primitives, Arrays, Enums, and proxy types.
*<p>
* Note that usually we shouldn't really be getting these sort of
* types anyway; but better safe than sorry.
*/
protected boolean isPotentialBeanType(Class<?> type)
{
String typeStr = ClassUtil.canBeABeanType(type);
if (typeStr != null) {
throw new IllegalArgumentException("Can not deserialize Class "+type.getName()+" (of type "+typeStr+") as a Bean");
}
if (ClassUtil.isProxyType(type)) {
throw new IllegalArgumentException("Can not deserialize Proxy class "+type.getName()+" as a Bean");
}
/* also: can't deserialize some local classes: static are ok; in-method not;
* other non-static inner classes are ok
*/
typeStr = ClassUtil.isLocalType(type, true);
if (typeStr != null) {
throw new IllegalArgumentException("Can not deserialize Class "+type.getName()+" (of type "+type
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.KeyDeserializers;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
import com.fasterxml.jackson.databind.util.ClassUtil;
import com.fasterxml.jackson.databind.util.EnumResolver;
/**
* Helper class used to contain simple/well-known key deserializers.
* Following kinds of Objects can be handled currently:
*<ul>
* <li>Primitive wrappers (Boolean, Byte, Char, Short, Integer, Float, Long, Double)</li>
* <li>Enums (usually not needed, since EnumMap doesn't call us)</li>
* <li>{@link java.util.Date}</li>
* <li>{@link java.util.Calendar}</li>
* <li>{@link java.util.UUID}</li>
* <li>{@link java.util.Locale}</li>
* <li>Anything with constructor that takes a single String arg
* (if not explicitly @JsonIgnore'd)</li>
* <li>Anything with {@code static T valueOf(String)} factory method
* (if not explicitly @JsonIgnore'd)</li>
*</ul>
*/
public class StdKeyDeserializers
implements KeyDeserializers, java.io.Serializable
{
private static final long serialVersionUID = 1L;
public static KeyDeserializer constructEnumKeyDeserializer(EnumResolver enumResolver) {
return new StdKeyDeserializer.EnumKD(enumResolver, null);
}
public static KeyDeserializer constructEnumKeyDeserializer(EnumResolver enumResolver,
AnnotatedMethod factory) {
return new StdKeyDeserializer.EnumKD(enumResolver, factory);
}
public static KeyDeserializer constructDelegatingKeyDeserializer(DeserializationConfig config,
JavaType type, JsonDeserializer<?> deser)
{
return new StdKeyDeserializer.DelegatingKD(type.getRawClass(), deser);
}
public static KeyDeserializer findStringBasedKeyDeserializer(DeserializationConfig config,
JavaType type)
{
/* We don't need full deserialization information, just need to
* know creators.
*/
BeanDescription beanDesc = config.int
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
/**
* Standard deserializer for {@link EnumSet}s.
* <p>
* Note: casting within this class is all messed up -- just could not figure out a way
* to properly deal with recursive definition of "EnumSet<K extends Enum<K>, V>
*/
@SuppressWarnings("rawtypes")
public class EnumSetDeserializer
extends StdDeserializer<EnumSet<?>>
implements ContextualDeserializer
{
private static final long serialVersionUID = 1L; // since 2.5
protected final JavaType _enumType;
protected final Class<Enum> _enumClass;
protected JsonDeserializer<Enum<?>> _enumDeserializer;
/**
* Specific override for this instance (from proper, or global per-type overrides)
* to indicate whether single value may be taken to mean an unwrapped one-element array
* or not. If null, left to global defaults.
*
* @since 2.7
*/
protected final Boolean _unwrapSingle;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
@SuppressWarnings("unchecked" )
public EnumSetDeserializer(JavaType enumType, JsonDeserializer<?> deser)
{
super(EnumSet.class);
_enumType = enumType;
_enumClass = (Class<Enum>) enumType.getRawClass();
// sanity check
if (!_enumClass.isEnum()) {
throw new IllegalArgumentException("Type "+enumType+" not Java Enum type");
}
_enumDeserializer = (JsonDeserializer<Enum<?>>) deser;
_unwrapSingle = null;
}
/**
* @since 2.7
*/
@SuppressWarnings("unchecked" )
protected EnumSetDeserializer(EnumSetDeserializer base,
JsonDeserializer<?> deser, Boolean unwrapSingle) {
super(EnumSet.class);
_enumType = base._enumType;
_enumClass = base._
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>enumClass;
_enumDeserializer = (JsonDeserializer<Enum<?>>) deser;
_unwrapSingle = unwrapSingle;
}
public EnumSetDeserializer withDeserializer(JsonDeserializer<?> deser) {
if (_enumDeserializer == deser) {
return this;
}
return new EnumSetDeserializer(this, deser, _unwrapSingle);
}
public EnumSetDeserializer withResolved(JsonDeserializer<?> deser, Boolean unwrapSingle) {
if ((_unwrapSingle == unwrapSingle) && (_enumDeserializer == deser)) {
return this;
}
return new EnumSetDeserializer(this, deser, unwrapSingle);
}
/**
* Because of costs associated with constructing Enum resolvers,
* let's cache instances by default.
*/
@Override
public boolean isCachable() {
// One caveat: content deserializer should prevent caching
if (_enumType.getValueHandler() != null) {
return false;
}
return true;
}
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
Boolean unwrapSingle = findFormatFeature(ctxt, property, EnumSet.class,
JsonFormat.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
JsonDeserializer<?> deser = _enumDeserializer;
if (deser == null) {
deser = ctxt.findContextualValueDeserializer(_enumType, property);
} else { // if directly assigned, probably not yet contextual, so:
deser = ctxt.handleSecondaryContextualization(deser, property, _enumType);
}
return withResolved(deser, unwrapSingle);
}
/*
/**********************************************************
/* JsonDeserializer API
/**********************************************************
*/
@SuppressWarnings("unchecked")
@Override
public EnumSet<?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException
{
// Ok: must point to START_ARRAY (or equivalent)
if (!p.isExpectedStartArrayToken()) {
return handleNonArray(p, ctxt);
}
EnumSet result = constructSet();
JsonToken t;
try {
while ((t = p.nextToken()) != JsonToken.END_ARRAY) {
/* What to do with nulls? Fail or ignore? Fail, for now
* (note: would fail if we passed it to EnumDeserializer, too,
* but in general
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.impl;
import java.io.IOException;
import java.util.Collection;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
/**
* Simple deserializer that will call configured type deserializer, passing
* in configured data deserializer, and exposing it all as a simple
* deserializer.
* This is necessary when there is no "parent" deserializer which could handle
* details of calling a {@link TypeDeserializer}, most commonly used with
* root values.
*/
public final class TypeWrappedDeserializer
extends JsonDeserializer<Object>
implements java.io.Serializable // since 2.5
{
private static final long serialVersionUID = 1L;
final protected TypeDeserializer _typeDeserializer;
final protected JsonDeserializer<Object> _deserializer;
@SuppressWarnings("unchecked")
public TypeWrappedDeserializer(TypeDeserializer typeDeser, JsonDeserializer<?> deser)
{
super();
_typeDeserializer = typeDeser;
_deserializer = (JsonDeserializer<Object>) deser;
}
@Override
public Class<?> handledType() {
return _deserializer.handledType();
}
@Override
public JsonDeserializer<?> getDelegatee() {
return _deserializer.getDelegatee();
}
@Override
public Collection<Object> getKnownPropertyNames() {
return _deserializer.getKnownPropertyNames();
}
@Override
public Object getNullValue(DeserializationContext ctxt) throws JsonMappingException {
return _deserializer.getNullValue(ctxt);
}
@Override
public Object getEmptyValue(DeserializationContext ctxt) throws JsonMappingException {
return _deserializer.getEmptyValue(ctxt);
}
@Override
public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException
{
return _deserializer.deserializeWithType(jp, ctxt, _typeDeserializer);
}
@Override
public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
TypeDeserializer typeDeserializer) throws IOException
{
// should never happen? (if it can, could call on that object)
throw new IllegalStateException("Type-wrapped deserializer's deserializeWithType should never get called");
}
@Override
public Object deserialize
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser;
import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.std.StdDelegatingDeserializer;
import com.fasterxml.jackson.databind.introspect.Annotated;
import com.fasterxml.jackson.databind.type.*;
import com.fasterxml.jackson.databind.util.ClassUtil;
import com.fasterxml.jackson.databind.util.Converter;
/**
* Class that defines caching layer between callers (like
* {@link ObjectMapper},
* {@link com.fasterxml.jackson.databind.DeserializationContext})
* and classes that construct deserializers
* ({@link com.fasterxml.jackson.databind.deser.DeserializerFactory}).
*/
public final class DeserializerCache
implements java.io.Serializable // since 2.1 -- needs to be careful tho
{
private static final long serialVersionUID = 1L;
/*
/**********************************************************
/* Caching
/**********************************************************
*/
/**
* We will also cache some dynamically constructed deserializers;
* specifically, ones that are expensive to construct.
* This currently means bean and Enum deserializers; starting with
* 2.5, container deserializers will also be cached.
*<p>
* Given that we don't expect much concurrency for additions
* (should very quickly converge to zero after startup), let's
* define a relatively low concurrency setting.
*/
final protected ConcurrentHashMap<JavaType, JsonDeserializer<Object>> _cachedDeserializers
= new ConcurrentHashMap<JavaType, JsonDeserializer<Object>>(64, 0.75f, 4);
/**
* During deserializer construction process we may need to keep track of partially
* completed deserializers, to resolve cyclic dependencies. This is the
* map used for storing deserializers before they are fully complete.
*/
final protected HashMap<JavaType, JsonDeserializer<Object>> _incompleteDeserializers
= new HashMap<JavaType, JsonDeserializer<Object>>(8);
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
public DeserializerCache() { }
/*
/**********************************************************
/* JDK serialization handling
/
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>ained using
* 'setter' method signature and/or type annotations
*
* @throws JsonMappingException if there are fatal problems with
* accessing suitable deserializer; including that of not
* finding any serializer
*/
public JsonDeserializer<Object> findValueDeserializer(DeserializationContext ctxt,
DeserializerFactory factory, JavaType propertyType)
throws JsonMappingException
{
JsonDeserializer<Object> deser = _findCachedDeserializer(propertyType);
if (deser == null) {
// If not, need to request factory to construct (or recycle)
deser = _createAndCacheValueDeserializer(ctxt, factory, propertyType);
if (deser == null) {
/* Should we let caller handle it? Let's have a helper method
* decide it; can throw an exception, or return a valid
* deserializer
*/
deser = _handleUnknownValueDeserializer(ctxt, propertyType);
}
}
return deser;
}
/**
* Method called to get hold of a deserializer to use for deserializing
* keys for {@link java.util.Map}.
*
* @throws JsonMappingException if there are fatal problems with
* accessing suitable key deserializer; including that of not
* finding any serializer
*/
public KeyDeserializer findKeyDeserializer(DeserializationContext ctxt,
DeserializerFactory factory, JavaType type)
throws JsonMappingException
{
KeyDeserializer kd = factory.createKeyDeserializer(ctxt, type);
if (kd == null) { // if none found, need to use a placeholder that'll fail
return _handleUnknownKeyDeserializer(ctxt, type);
}
// First: need to resolve?
if (kd instanceof ResolvableDeserializer) {
((ResolvableDeserializer) kd).resolve(ctxt);
}
return kd;
}
/**
* Method called to find out whether provider would be able to find
* a deserializer for given type, using a root reference (i.e. not
* through fields or membership in an array or collection)
*/
public boolean hasValueDeserializerFor(DeserializationContext ctxt,
DeserializerFactory factory, JavaType type)
throws JsonMappingException
{
/* Note: mostly copied from findValueDeserializer, except for
* handling of unknown types
*/
JsonDeserializer<Object> deser = _findCachedDeserializer(type);
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
if (deser == null) {
deser = _createAndCacheValueDeserializer(ctxt, factory, type);
}
return (deser != null);
}
/*
/**********************************************************
/* Helper methods that handle cache lookups
/**********************************************************
*/
protected JsonDeserializer<Object> _findCachedDeserializer(JavaType type)
{
if (type == null) {
throw new IllegalArgumentException("Null JavaType passed");
}
if (_hasCustomValueHandler(type)) {
return null;
}
return _cachedDeserializers.get(type);
}
/**
* Method that will try to create a deserializer for given type,
* and resolve and cache it if necessary
*
* @param ctxt Currently active deserialization context
* @param type Type of property to deserialize
*/
protected JsonDeserializer<Object> _createAndCacheValueDeserializer(DeserializationContext ctxt,
DeserializerFactory factory, JavaType type)
throws JsonMappingException
{
/* Only one thread to construct deserializers at any given point in time;
* limitations necessary to ensure that only completely initialized ones
* are visible and used.
*/
synchronized (_incompleteDeserializers) {
// Ok, then: could it be that due to a race condition, deserializer can now be found?
JsonDeserializer<Object> deser = _findCachedDeserializer(type);
if (deser != null) {
return deser;
}
int count = _incompleteDeserializers.size();
// Or perhaps being resolved right now?
if (count > 0) {
deser = _incompleteDeserializers.get(type);
if (deser != null) {
return deser;
}
}
// Nope: need to create and possibly cache
try {
return _createAndCache2(ctxt, factory, type);
} finally {
// also: any deserializers that have been created are complete by now
if (count == 0 && _incompleteDeserializers.size() > 0) {
_incompleteDeserializers.clear();
}
}
}
}
/**
* Method that handles actual construction (via factory) and caching (both
* intermediate and eventual)
*/
protected JsonDeserializer<Object> _createAndCache2(DeserializationContext ctxt,
DeserializerFactory factory, JavaType type)
throws
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> JsonMappingException
{
JsonDeserializer<Object> deser;
try {
deser = _createDeserializer(ctxt, factory, type);
} catch (IllegalArgumentException iae) {
// We better only expose checked exceptions, since those
// are what caller is expected to handle
throw JsonMappingException.from(ctxt, iae.getMessage(), iae);
}
if (deser == null) {
return null;
}
/* cache resulting deserializer? always true for "plain" BeanDeserializer
* (but can be re-defined for sub-classes by using @JsonCachable!)
*/
// 27-Mar-2015, tatu: As per [databind#735], avoid caching types with custom value desers
boolean addToCache = !_hasCustomValueHandler(type) && deser.isCachable();
/* we will temporarily hold on to all created deserializers (to
* handle cyclic references, and possibly reuse non-cached
* deserializers (list, map))
*/
/* 07-Jun-2010, tatu: Danger: [JACKSON-296] was caused by accidental
* resolution of a reference -- couple of ways to prevent this;
* either not add Lists or Maps, or clear references eagerly.
* Let's actually do both; since both seem reasonable.
*/
/* Need to resolve? Mostly done for bean deserializers; required for
* resolving cyclic references.
*/
if (deser instanceof ResolvableDeserializer) {
_incompleteDeserializers.put(type, deser);
((ResolvableDeserializer)deser).resolve(ctxt);
_incompleteDeserializers.remove(type);
}
if (addToCache) {
_cachedDeserializers.put(type, deser);
}
return deser;
}
/*
/**********************************************************
/* Helper methods for actual construction of deserializers
/**********************************************************
*/
/**
* Method that does the heavy lifting of checking for per-type annotations,
* find out full type, and figure out which actual factory method
* to call.
*/
@SuppressWarnings("unchecked")
protected JsonDeserializer<Object> _createDeserializer(DeserializationContext ctxt,
DeserializerFactory factory, JavaType type)
throws JsonMappingException
{
final Deserialization
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Config config = ctxt.getConfig();
// First things first: do we need to use abstract type mapping?
if (type.isAbstract() || type.isMapLikeType() || type.isCollectionLikeType()) {
type = factory.mapAbstractType(config, type);
}
BeanDescription beanDesc = config.introspect(type);
// Then: does type define explicit deserializer to use, with annotation(s)?
JsonDeserializer<Object> deser = findDeserializerFromAnnotation(ctxt,
beanDesc.getClassInfo());
if (deser != null) {
return deser;
}
// If not, may have further type-modification annotations to check:
JavaType newType = modifyTypeByAnnotation(ctxt, beanDesc.getClassInfo(), type);
if (newType != type) {
type = newType;
beanDesc = config.introspect(newType);
}
// We may also have a Builder type to consider...
Class<?> builder = beanDesc.findPOJOBuilder();
if (builder != null) {
return (JsonDeserializer<Object>) factory.createBuilderBasedDeserializer(
ctxt, type, beanDesc, builder);
}
// Or perhaps a Converter?
Converter<Object,Object> conv = beanDesc.findDeserializationConverter();
if (conv == null) { // nope, just construct in normal way
return (JsonDeserializer<Object>) _createDeserializer2(ctxt, factory, type, beanDesc);
}
// otherwise need to do bit of introspection
JavaType delegateType = conv.getInputType(ctxt.getTypeFactory());
// One more twist, as per [databind#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
}
return new StdDelegatingDeserializer<Object>(conv, delegateType,
_createDeserializer2(ctxt, factory, delegateType, beanDesc));
}
protected JsonDeserializer<?> _createDeserializer2(DeserializationContext ctxt,
DeserializerFactory factory, JavaType type, BeanDescription beanDesc)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
// If not, let's see which factory method to use:
if (type.isEnumType()) {
return factory.createEnumDeserializer
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>(ctxt, type, beanDesc);
}
if (type.isContainerType()) {
if (type.isArrayType()) {
return factory.createArrayDeserializer(ctxt, (ArrayType) type, beanDesc);
}
if (type.isMapLikeType()) {
MapLikeType mlt = (MapLikeType) type;
if (mlt.isTrueMapType()) {
return factory.createMapDeserializer(ctxt,(MapType) mlt, beanDesc);
}
return factory.createMapLikeDeserializer(ctxt, mlt, beanDesc);
}
if (type.isCollectionLikeType()) {
/* 03-Aug-2012, tatu: As per [databind#40], one exception is if shape
* is to be Shape.OBJECT. Ideally we'd determine it bit later on
* (to allow custom handler checks), but that won't work for other
* reasons. So do it here.
*/
JsonFormat.Value format = beanDesc.findExpectedFormat(null);
if ((format == null) || format.getShape() != JsonFormat.Shape.OBJECT) {
CollectionLikeType clt = (CollectionLikeType) type;
if (clt.isTrueCollectionType()) {
return factory.createCollectionDeserializer(ctxt, (CollectionType) clt, beanDesc);
}
return factory.createCollectionLikeDeserializer(ctxt, clt, beanDesc);
}
}
}
if (type.isReferenceType()) {
return factory.createReferenceDeserializer(ctxt, (ReferenceType) type, beanDesc);
}
if (JsonNode.class.isAssignableFrom(type.getRawClass())) {
return factory.createTreeDeserializer(config, type, beanDesc);
}
return factory.createBeanDeserializer(ctxt, type, beanDesc);
}
/**
* Helper method called to check if a class or method
* has annotation that tells which class to use for deserialization.
* Returns null if no such annotation found.
*/
protected JsonDeserializer<Object> findDeserializerFromAnnotation(DeserializationContext ctxt,
Annotated ann)
throws JsonMappingException
{
Object deserDef = ctxt.getAnnotationIntrospector().findDeserializer(ann);
if (deserDef == null) {
return null;
}
JsonDeserializer<Object> deser
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> = ctxt.deserializerInstance(ann, deserDef);
// One more thing however: may need to also apply a converter:
return findConvertingDeserializer(ctxt, ann, deser);
}
/**
* Helper method that will check whether given annotated entity (usually class,
* but may also be a property accessor) indicates that a {@link Converter} is to
* be used; and if so, to construct and return suitable serializer for it.
* If not, will simply return given serializer as is.
*/
protected JsonDeserializer<Object> findConvertingDeserializer(DeserializationContext ctxt,
Annotated a, JsonDeserializer<Object> deser)
throws JsonMappingException
{
Converter<Object,Object> conv = findConverter(ctxt, a);
if (conv == null) {
return deser;
}
JavaType delegateType = conv.getInputType(ctxt.getTypeFactory());
return (JsonDeserializer<Object>) new StdDelegatingDeserializer<Object>(conv, delegateType, deser);
}
protected Converter<Object,Object> findConverter(DeserializationContext ctxt,
Annotated a)
throws JsonMappingException
{
Object convDef = ctxt.getAnnotationIntrospector().findDeserializationConverter(a);
if (convDef == null) {
return null;
}
return ctxt.converterInstance(a, convDef);
}
/**
* Method called to see if given method has annotations that indicate
* a more specific type than what the argument specifies.
* If annotations are present, they must specify compatible Class;
* instance of which can be assigned using the method. This means
* that the Class has to be raw class of type, or its sub-class
* (or, implementing class if original Class instance is an interface).
*
* @param a Method or field that the type is associated with
* @param type Type derived from the setter argument
*
* @return Original type if no annotations are present; or a more
* specific type derived from it if type annotation(s) was found
*
* @throws JsonMappingException if invalid annotation is found
*/
private JavaType modifyTypeByAnnotation(DeserializationContext ctxt,
Annotated a, JavaType type)
throws JsonMappingException
{
AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
if (intr == null) {
return type;
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> }
// First things first: find explicitly annotated deserializer(s)
// then key/value handlers (annotated deserializers)?
if (type.isMapLikeType()) {
JavaType keyType = type.getKeyType();
// 21-Mar-2011, tatu: ... and associated deserializer too (unless already assigned)
// (not 100% why or how, but this does seem to get called more than once, which
// is not good: for now, let's just avoid errors)
if (keyType != null && keyType.getValueHandler() == null) {
Object kdDef = intr.findKeyDeserializer(a);
if (kdDef != null) {
KeyDeserializer kd = ctxt.keyDeserializerInstance(a, kdDef);
if (kd != null) {
type = ((MapLikeType) type).withKeyValueHandler(kd);
keyType = type.getKeyType(); // just in case it's used below
}
}
}
}
JavaType contentType = type.getContentType();
if (contentType != null) {
if (contentType.getValueHandler() == null) { // as with above, avoid resetting (which would trigger exception)
Object cdDef = intr.findContentDeserializer(a);
if (cdDef != null) {
JsonDeserializer<?> cd = null;
if (cdDef instanceof JsonDeserializer<?>) {
cdDef = (JsonDeserializer<?>) cdDef;
} else {
Class<?> cdClass = _verifyAsClass(cdDef, "findContentDeserializer", JsonDeserializer.None.class);
if (cdClass != null) {
cd = ctxt.deserializerInstance(a, cdClass);
}
}
if (cd != null) {
type = type.withContentValueHandler(cd);
}
}
}
}
// And after handlers, possible type refinements
// (note: could possibly avoid this if explicit deserializer was invoked?)
type = intr.refineDeserializationType(ctxt.getConfig(), a, type);
return type;
}
/*
/**********************************************************
/* Helper methods, other
/**********************************************************
*/
/**
* Helper method used to prevent both caching and cache lookups for structured
* types that have custom value handlers
*
* @
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>since 2.4.6
*/
private boolean _hasCustomValueHandler(JavaType t) {
if (t.isContainerType()) {
JavaType ct = t.getContentType();
if (ct != null) {
return (ct.getValueHandler() != null) || (ct.getTypeHandler() != null);
}
}
return false;
}
private Class<?> _verifyAsClass(Object src, String methodName, Class<?> noneClass)
{
if (src == null) {
return null;
}
if (!(src instanceof Class)) {
throw new IllegalStateException("AnnotationIntrospector."+methodName+"() returned value of type "+src.getClass().getName()+": expected type JsonSerializer or Class<JsonSerializer> instead");
}
Class<?> cls = (Class<?>) src;
if (cls == noneClass || ClassUtil.isBogusClass(cls)) {
return null;
}
return cls;
}
/*
/**********************************************************
/* Overridable error reporting methods
/**********************************************************
*/
// NOTE: changed 2.6 -> 2.7 to pass context; no way to make backwards compatible
protected JsonDeserializer<Object> _handleUnknownValueDeserializer(DeserializationContext ctxt, JavaType type)
throws JsonMappingException
{
/* Let's try to figure out the reason, to give better error
* messages
*/
Class<?> rawClass = type.getRawClass();
if (!ClassUtil.isConcrete(rawClass)) {
ctxt.reportMappingException("Can not find a Value deserializer for abstract type %s", type);
}
ctxt.reportMappingException("Can not find a Value deserializer for type %s", type);
return null;
}
protected KeyDeserializer _handleUnknownKeyDeserializer(DeserializationContext ctxt, JavaType type)
throws JsonMappingException
{
ctxt.reportMappingException("Can not find a (Map) Key deserializer for type %s", type);
return null;
}
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.core.io.NumberInput;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.ClassUtil;
import com.fasterxml.jackson.databind.util.Converter;
/**
* Base class for common deserializers. Contains shared
* base functionality for dealing with primitive values, such
* as (re)parsing from String.
*/
public abstract class StdDeserializer<T>
extends JsonDeserializer<T>
implements java.io.Serializable
{
private static final long serialVersionUID = 1L;
/**
* Bitmask that covers {@link DeserializationFeature#USE_BIG_INTEGER_FOR_INTS}
* and {@link DeserializationFeature#USE_LONG_FOR_INTS}, used for more efficient
* cheks when coercing integral values for untyped deserialization.
*
* @since 2.6
*/
protected final static int F_MASK_INT_COERCIONS =
DeserializationFeature.USE_BIG_INTEGER_FOR_INTS.getMask()
| DeserializationFeature.USE_LONG_FOR_INTS.getMask();
/**
* Type of values this deserializer handles: sometimes
* exact types, other time most specific supertype of
* types deserializer handles (which may be as generic
* as {@link Object} in some case)
*/
final protected Class<?> _valueClass;
protected StdDeserializer(Class<?> vc) {
_valueClass = vc;
}
protected StdDeserializer(JavaType valueType) {
_valueClass = (valueType == null) ? null : valueType.getRawClass();
}
/**
* Copy-constructor for sub-classes to use, most often when creating
* new instances for {@link com.fasterxml.jackson.databind.deser.ContextualDeserializer}.
*
* @
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>since 2.5
*/
protected StdDeserializer(StdDeserializer<?> src) {
_valueClass = src._valueClass;
}
/*
/**********************************************************
/* Accessors
/**********************************************************
*/
@Override
public Class<?> handledType() { return _valueClass; }
/*
/**********************************************************
/* Extended API
/**********************************************************
*/
/**
* @deprecated Since 2.3 use {@link #handledType} instead
*/
@Deprecated
public final Class<?> getValueClass() { return _valueClass; }
/**
* Exact structured type deserializer handles, if known.
*<p>
* Default implementation just returns null.
*/
public JavaType getValueType() { return null; }
/**
* Method that can be called to determine if given deserializer is the default
* deserializer Jackson uses; as opposed to a custom deserializer installed by
* a module or calling application. Determination is done using
* {@link JacksonStdImpl} annotation on deserializer class.
*/
protected boolean isDefaultDeserializer(JsonDeserializer<?> deserializer) {
return ClassUtil.isJacksonStdImpl(deserializer);
}
protected boolean isDefaultKeyDeserializer(KeyDeserializer keyDeser) {
return ClassUtil.isJacksonStdImpl(keyDeser);
}
/*
/**********************************************************
/* Partial JsonDeserializer implementation
/**********************************************************
*/
/**
* Base implementation that does not assume specific type
* inclusion mechanism. Sub-classes are expected to override
* this method if they are to handle type information.
*/
@Override
public Object deserializeWithType(JsonParser p, DeserializationContext ctxt,
TypeDeserializer typeDeserializer) throws IOException {
return typeDeserializer.deserializeTypedFromAny(p, ctxt);
}
/*
/**********************************************************
/* Helper methods for sub-classes, parsing: while mostly
/* useful for numeric types, can be also useful for dealing
/* with things serialized as numbers (such as Dates).
/**********************************************************
*/
protected final boolean _parseBooleanPrimitive(JsonParser p, DeserializationContext ctxt) throws IOException
{
JsonToken t = p.getCurrentToken();
if (t == JsonToken.VALUE_TRUE) return true;
if (t == JsonToken.VALUE_FALSE) return false;
if (t == JsonToken.VALUE_NULL
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>****************************************************
/* Helper methods for sub-classes, resolving dependencies
/****************************************************
*/
/**
* Helper method used to locate deserializers for properties the
* type this deserializer handles contains (usually for properties of
* bean types)
*
* @param type Type of property to deserialize
* @param property Actual property object (field, method, constuctor parameter) used
* for passing deserialized values; provided so deserializer can be contextualized if necessary
*/
protected JsonDeserializer<Object> findDeserializer(DeserializationContext ctxt,
JavaType type, BeanProperty property)
throws JsonMappingException
{
return ctxt.findContextualValueDeserializer(type, property);
}
/**
* Helper method to check whether given text refers to what looks like a clean simple
* integer number, consisting of optional sign followed by a sequence of digits.
*/
protected final boolean _isIntNumber(String text)
{
final int len = text.length();
if (len > 0) {
char c = text.charAt(0);
// skip leading sign (plus not allowed for strict JSON numbers but...)
int i = (c == '-' || c == '+') ? 1 : 0;
for (; i < len; ++i) {
int ch = text.charAt(i);
if (ch > '9' || ch < '0') {
return false;
}
}
return true;
}
return false;
}
/*
/**********************************************************
/* Helper methods for sub-classes, deserializer construction
/**********************************************************
*/
/**
* Helper method that can be used to see if specified property has annotation
* indicating that a converter is to be used for contained values (contents
* of structured types; array/List/Map values)
*
* @param existingDeserializer (optional) configured content
* serializer if one already exists.
*
* @since 2.2
*/
protected JsonDeserializer<?> findConvertingContentDeserializer(DeserializationContext ctxt,
BeanProperty prop, JsonDeserializer<?> existingDeserializer)
throws JsonMappingException
{
final AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
if (intr != null && prop != null) {
AnnotatedMember member = prop.getMember();
if (member != null) {
Object convDef = intr.findDeserialization
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.ObjectBuffer;
/**
* Separate implementation for serializing String arrays (instead of
* using {@link ObjectArrayDeserializer}.
* Used if (and only if) no custom value deserializers are used.
*/
@JacksonStdImpl
public final class StringArrayDeserializer
extends StdDeserializer<String[]>
implements ContextualDeserializer
{
private static final long serialVersionUID = 2L;
public final static StringArrayDeserializer instance = new StringArrayDeserializer();
/**
* Value serializer to use, if not the standard one (which is inlined)
*/
protected JsonDeserializer<String> _elementDeserializer;
/**
* Specific override for this instance (from proper, or global per-type overrides)
* to indicate whether single value may be taken to mean an unwrapped one-element array
* or not. If null, left to global defaults.
*
* @since 2.7
*/
protected final Boolean _unwrapSingle;
public StringArrayDeserializer() {
this(null, null);
}
@SuppressWarnings("unchecked")
protected StringArrayDeserializer(JsonDeserializer<?> deser, Boolean unwrapSingle) {
super(String[].class);
_elementDeserializer = (JsonDeserializer<String>) deser;
_unwrapSingle = unwrapSingle;
}
/**
* Contextualization is needed to see whether we can "inline" deserialization
* of String values, or if we have to use separate value deserializer.
*/
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException
{
JsonDeserializer<?> deser = _elementDeserializer;
// May have a content converter
deser = findConvertingContentDeserializer(ctxt, property, deser);
JavaType type = ctxt.constructType(String.class);
if (deser == null) {
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> deser = ctxt.findContextualValueDeserializer(type, property);
} else { // if directly assigned, probably not yet contextual, so:
deser = ctxt.handleSecondaryContextualization(deser, property, type);
}
// One more thing: allow unwrapping?
Boolean unwrapSingle = findFormatFeature(ctxt, property, String[].class,
JsonFormat.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
// Ok ok: if all we got is the default String deserializer, can just forget about it
if ((deser != null) && isDefaultDeserializer(deser)) {
deser = null;
}
if ((_elementDeserializer == deser) && (_unwrapSingle == unwrapSingle)) {
return this;
}
return new StringArrayDeserializer(deser, unwrapSingle);
}
@Override
public String[] deserialize(JsonParser p, DeserializationContext ctxt) throws IOException
{
// Ok: must point to START_ARRAY (or equivalent)
if (!p.isExpectedStartArrayToken()) {
return handleNonArray(p, ctxt);
}
if (_elementDeserializer != null) {
return _deserializeCustom(p, ctxt);
}
final ObjectBuffer buffer = ctxt.leaseObjectBuffer();
Object[] chunk = buffer.resetAndStart();
int ix = 0;
try {
while (true) {
String value = p.nextTextValue();
if (value == null) {
JsonToken t = p.getCurrentToken();
if (t == JsonToken.END_ARRAY) {
break;
}
if (t != JsonToken.VALUE_NULL) {
value = _parseString(p, ctxt);
}
}
if (ix >= chunk.length) {
chunk = buffer.appendCompletedChunk(chunk);
ix = 0;
}
chunk[ix++] = value;
}
} catch (Exception e) {
throw JsonMappingException.wrapWithPath(e, chunk, buffer.bufferedSize() + ix);
}
String[] result = buffer.completeAndClearBuffer(chunk, ix, String.class);
ctxt.returnObjectBuffer(buffer);
return result;
}
/**
* Offlined version used when we do not use the default deserialization method.
*/
protected final String[] _deserializeCustom(JsonParser
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> p, DeserializationContext ctxt) throws IOException
{
final ObjectBuffer buffer = ctxt.leaseObjectBuffer();
Object[] chunk = buffer.resetAndStart();
final JsonDeserializer<String> deser = _elementDeserializer;
int ix = 0;
try {
while (true) {
/* 30-Dec-2014, tatu: This may look odd, but let's actually call method
* that suggest we are expecting a String; this helps with some formats,
* notably XML. Note, however, that while we can get String, we can't
* assume that's what we use due to custom deserializer
*/
String value;
if (p.nextTextValue() == null) {
JsonToken t = p.getCurrentToken();
if (t == JsonToken.END_ARRAY) {
break;
}
// Ok: no need to convert Strings, but must recognize nulls
value = (t == JsonToken.VALUE_NULL) ? deser.getNullValue(ctxt) : deser.deserialize(p, ctxt);
} else {
value = deser.deserialize(p, ctxt);
}
if (ix >= chunk.length) {
chunk = buffer.appendCompletedChunk(chunk);
ix = 0;
}
chunk[ix++] = value;
}
} catch (Exception e) {
// note: pass String.class, not String[].class, as we need element type for error info
throw JsonMappingException.wrapWithPath(e, String.class, ix);
}
String[] result = buffer.completeAndClearBuffer(chunk, ix, String.class);
ctxt.returnObjectBuffer(buffer);
return result;
}
@Override
public Object deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException {
return typeDeserializer.deserializeTypedFromArray(p, ctxt);
}
private final String[] handleNonArray(JsonParser p, DeserializationContext ctxt) throws IOException
{
// implicit arrays from single values?
boolean canWrap = (_unwrapSingle == Boolean.TRUE) ||
((_unwrapSingle == null) &&
ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY));
if (canWrap) {
return new String[] { p.hasToken(JsonToken.VALUE
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.util.Collection;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.deser.ValueInstantiator;
import com.fasterxml.jackson.databind.introspect.AnnotatedWithParams;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
/**
* Specifically optimized version for {@link java.util.Collection}s
* that contain String values; reason is that this is a very common
* type and we can make use of the fact that Strings are final.
*/
@JacksonStdImpl
public final class StringCollectionDeserializer
extends ContainerDeserializerBase<Collection<String>>
implements ContextualDeserializer
{
private static final long serialVersionUID = 1L;
// // Configuration
protected final JavaType _collectionType;
/**
* Value deserializer to use, if NOT the standard one
* (if it is, will be null).
*/
protected final JsonDeserializer<String> _valueDeserializer;
// // Instance construction settings:
/**
* Instantiator used in case custom handling is needed for creation.
*/
protected final ValueInstantiator _valueInstantiator;
/**
* Deserializer that is used iff delegate-based creator is
* to be used for deserializing from JSON Object.
*/
protected final JsonDeserializer<Object> _delegateDeserializer;
/**
* Specific override for this instance (from proper, or global per-type overrides)
* to indicate whether single value may be taken to mean an unwrapped one-element array
* or not. If null, left to global defaults.
*
* @since 2.7
*/
protected final Boolean _unwrapSingle;
// NOTE: no PropertyBasedCreator, as JSON Arrays have no properties
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
public StringCollectionDeserializer(JavaType collectionType,
JsonDeserializer<?> valueDeser, ValueInstantiator valueInstantiator)
{
this(collectionType, value
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Instantiator, null, valueDeser, null);
}
@SuppressWarnings("unchecked")
protected StringCollectionDeserializer(JavaType collectionType,
ValueInstantiator valueInstantiator, JsonDeserializer<?> delegateDeser,
JsonDeserializer<?> valueDeser, Boolean unwrapSingle)
{
super(collectionType);
_collectionType = collectionType;
_valueDeserializer = (JsonDeserializer<String>) valueDeser;
_valueInstantiator = valueInstantiator;
_delegateDeserializer = (JsonDeserializer<Object>) delegateDeser;
_unwrapSingle = unwrapSingle;
}
protected StringCollectionDeserializer withResolved(JsonDeserializer<?> delegateDeser,
JsonDeserializer<?> valueDeser, Boolean unwrapSingle)
{
if ((_unwrapSingle == unwrapSingle)
&& (_valueDeserializer == valueDeser) && (_delegateDeserializer == delegateDeser)) {
return this;
}
return new StringCollectionDeserializer(_collectionType,
_valueInstantiator, delegateDeser, valueDeser, unwrapSingle);
}
@Override // since 2.5
public boolean isCachable() {
// 26-Mar-2015, tatu: Important: prevent caching if custom deserializers are involved
return (_valueDeserializer == null) && (_delegateDeserializer == null);
}
/*
/**********************************************************
/* Validation, post-processing
/**********************************************************
*/
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
// May need to resolve types for delegate-based creators:
JsonDeserializer<Object> delegate = null;
if (_valueInstantiator != null) {
AnnotatedWithParams delegateCreator = _valueInstantiator.getDelegateCreator();
if (delegateCreator != null) {
JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig());
delegate = findDeserializer(ctxt, delegateType, property);
}
}
JsonDeserializer<?> valueDeser = _valueDeserializer;
final JavaType valueType = _collectionType.getContentType();
if (valueDeser == null) {
// [databind#125]: May have a content converter
valueDeser = findConvertingContentDeserializer(ctxt, property, valueDeser);
if (valueDeser == null) {
// And we may also need to get de
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>serializer for String
valueDeser = ctxt.findContextualValueDeserializer(valueType, property);
}
} else { // if directly assigned, probably not yet contextual, so:
valueDeser = ctxt.handleSecondaryContextualization(valueDeser, property, valueType);
}
// 11-Dec-2015, tatu: Should we pass basic `Collection.class`, or more refined? Mostly
// comes down to "List vs Collection" I suppose... for now, pass Collection
Boolean unwrapSingle = findFormatFeature(ctxt, property, Collection.class,
JsonFormat.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
if (isDefaultDeserializer(valueDeser)) {
valueDeser = null;
}
return withResolved(delegate, valueDeser, unwrapSingle);
}
/*
/**********************************************************
/* ContainerDeserializerBase API
/**********************************************************
*/
@Override
public JavaType getContentType() {
return _collectionType.getContentType();
}
@SuppressWarnings("unchecked")
@Override
public JsonDeserializer<Object> getContentDeserializer() {
JsonDeserializer<?> deser = _valueDeserializer;
return (JsonDeserializer<Object>) deser;
}
/*
/**********************************************************
/* JsonDeserializer API
/**********************************************************
*/
@SuppressWarnings("unchecked")
@Override
public Collection<String> deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException
{
if (_delegateDeserializer != null) {
return (Collection<String>) _valueInstantiator.createUsingDelegate(ctxt,
_delegateDeserializer.deserialize(p, ctxt));
}
final Collection<String> result = (Collection<String>) _valueInstantiator.createUsingDefault(ctxt);
return deserialize(p, ctxt, result);
}
@Override
public Collection<String> deserialize(JsonParser p, DeserializationContext ctxt,
Collection<String> result)
throws IOException
{
// Ok: must point to START_ARRAY
if (!p.isExpectedStartArrayToken()) {
return handleNonArray(p, ctxt, result);
}
if (_valueDeserializer != null) {
return deserializeUsingCustom(p, ctxt, result, _valueDeserializer);
}
try {
while (true) {
// First the common case:
String value = p.nextText
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Value();
if (value != null) {
result.add(value);
continue;
}
JsonToken t = p.getCurrentToken();
if (t == JsonToken.END_ARRAY) {
break;
}
if (t != JsonToken.VALUE_NULL) {
value = _parseString(p, ctxt);
}
result.add(value);
}
} catch (Exception e) {
throw JsonMappingException.wrapWithPath(e, result, result.size());
}
return result;
}
private Collection<String> deserializeUsingCustom(JsonParser p, DeserializationContext ctxt,
Collection<String> result, final JsonDeserializer<String> deser) throws IOException
{
while (true) {
/* 30-Dec-2014, tatu: This may look odd, but let's actually call method
* that suggest we are expecting a String; this helps with some formats,
* notably XML. Note, however, that while we can get String, we can't
* assume that's what we use due to custom deserializer
*/
String value;
if (p.nextTextValue() == null) {
JsonToken t = p.getCurrentToken();
if (t == JsonToken.END_ARRAY) {
break;
}
// Ok: no need to convert Strings, but must recognize nulls
value = (t == JsonToken.VALUE_NULL) ? deser.getNullValue(ctxt) : deser.deserialize(p, ctxt);
} else {
value = deser.deserialize(p, ctxt);
}
result.add(value);
}
return result;
}
@Override
public Object deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException {
// In future could check current token... for now this should be enough:
return typeDeserializer.deserializeTypedFromArray(p, ctxt);
}
/**
* Helper method called when current token is not START_ARRAY. Will either
* throw an exception, or try to handle value as if member of implicit
* array, depending on configuration.
*/
@SuppressWarnings("unchecked")
private final Collection<String> handleNonArray(JsonParser p, DeserializationContext ctxt, Collection<String> result) throws IOException
{
// implicit arrays from
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> single values?
boolean canWrap = (_unwrapSingle == Boolean.TRUE) ||
((_unwrapSingle == null) &&
ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY));
if (!canWrap) {
return (Collection<String>) ctxt.handleUnexpectedToken(_collectionType.getRawClass(), p);
}
// Strings are one of "native" (intrinsic) types, so there's never type deserializer involved
JsonDeserializer<String> valueDes = _valueDeserializer;
JsonToken t = p.getCurrentToken();
String value;
if (t == JsonToken.VALUE_NULL) {
value = (valueDes == null) ? null : valueDes.getNullValue(ctxt);
} else {
value = (valueDes == null) ? _parseString(p, ctxt) : valueDes.deserialize(p, ctxt);
}
result.add(value);
return result;
}
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> polymorphic type
* information, if one is needed
* @param contextAnnotations Contextual annotations (usually by class that
* declares creator [constructor, factory method] that includes
* this property)
* @param param Representation of property, constructor or factory
* method parameter; used for accessing annotations of the property
* @param index Index of this property within creator invocation
*
* @since 2.3
*/
public CreatorProperty(PropertyName name, JavaType type, PropertyName wrapperName,
TypeDeserializer typeDeser,
Annotations contextAnnotations, AnnotatedParameter param,
int index, Object injectableValueId,
PropertyMetadata metadata)
{
super(name, type, wrapperName, typeDeser, contextAnnotations, metadata);
_annotated = param;
_creatorIndex = index;
_injectableValueId = injectableValueId;
_fallbackSetter = null;
}
/**
* @since 2.3
*/
protected CreatorProperty(CreatorProperty src, PropertyName newName) {
super(src, newName);
_annotated = src._annotated;
_creatorIndex = src._creatorIndex;
_injectableValueId = src._injectableValueId;
_fallbackSetter = src._fallbackSetter;
}
protected CreatorProperty(CreatorProperty src, JsonDeserializer<?> deser) {
super(src, deser);
_annotated = src._annotated;
_creatorIndex = src._creatorIndex;
_injectableValueId = src._injectableValueId;
_fallbackSetter = src._fallbackSetter;
}
@Override
public CreatorProperty withName(PropertyName newName) {
return new CreatorProperty(this, newName);
}
@Override
public CreatorProperty withValueDeserializer(JsonDeserializer<?> deser) {
return new CreatorProperty(this, deser);
}
@Override
public void fixAccess(DeserializationConfig config) {
if (_fallbackSetter != null) {
_fallbackSetter.fixAccess(config);
}
}
/**
* NOTE: one exception to immutability, due to problems with CreatorProperty instances
* being shared between Bean, separate PropertyBasedCreator
*
* @since 2.6.0
*/
public void setFallbackSetter(SettableBeanProperty fallbackSetter) {
_fallbackSetter = fallbackSetter;
}
/**
*
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.impl;
import java.io.IOException;
import java.lang.annotation.Annotation;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.*;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
/**
* Specialized {@link SettableBeanProperty} implementation used
* for virtual property that represents Object Id that is used
* for some POJO types (or properties).
*/
public final class ObjectIdValueProperty
extends SettableBeanProperty
{
private static final long serialVersionUID = 1L;
protected final ObjectIdReader _objectIdReader;
public ObjectIdValueProperty(ObjectIdReader objectIdReader,
PropertyMetadata metadata)
{
super(objectIdReader.propertyName, objectIdReader.getIdType(), metadata,
objectIdReader.getDeserializer());
_objectIdReader = objectIdReader;
}
protected ObjectIdValueProperty(ObjectIdValueProperty src, JsonDeserializer<?> deser)
{
super(src, deser);
_objectIdReader = src._objectIdReader;
}
protected ObjectIdValueProperty(ObjectIdValueProperty src, PropertyName newName) {
super(src, newName);
_objectIdReader = src._objectIdReader;
}
@Override
public ObjectIdValueProperty withName(PropertyName newName) {
return new ObjectIdValueProperty(this, newName);
}
@Override
public ObjectIdValueProperty withValueDeserializer(JsonDeserializer<?> deser) {
return new ObjectIdValueProperty(this, deser);
}
// // // BeanProperty impl
@Override
public <A extends Annotation> A getAnnotation(Class<A> acls) {
return null;
}
@Override public AnnotatedMember getMember() { return null; }
/*
/**********************************************************
/* Deserialization methods
/**********************************************************
*/
@Override
public void deserializeAndSet(JsonParser p, DeserializationContext ctxt,
Object instance) throws IOException
{
deserializeSetAndReturn(p, ctxt, instance);
}
@Override
public Object deserializeSetAndReturn(JsonParser p,
DeserializationContext ctxt, Object instance) throws IOException
{
/* 02-Apr-2015, tatu
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.ValueInstantiator;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
/**
* We need a custom deserializer both because {@link ArrayBlockingQueue} has no
* default constructor AND because it has size limit used for constructing
* underlying storage automatically.
*/
public class ArrayBlockingQueueDeserializer
extends CollectionDeserializer
{
private static final long serialVersionUID = 1;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
public ArrayBlockingQueueDeserializer(JavaType collectionType,
JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser,
ValueInstantiator valueInstantiator)
{
super(collectionType, valueDeser, valueTypeDeser, valueInstantiator);
}
/**
* Constructor used when creating contextualized instances.
*/
protected ArrayBlockingQueueDeserializer(JavaType collectionType,
JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser,
ValueInstantiator valueInstantiator,
JsonDeserializer<Object> delegateDeser, Boolean unwrapSingle)
{
super(collectionType, valueDeser, valueTypeDeser, valueInstantiator,
delegateDeser, unwrapSingle);
}
/**
* Copy-constructor that can be used by sub-classes to allow
* copy-on-write styling copying of settings of an existing instance.
*/
protected ArrayBlockingQueueDeserializer(ArrayBlockingQueueDeserializer src) {
super(src);
}
/**
* Fluent-factory method call to construct contextual instance.
*/
@Override
@SuppressWarnings("unchecked")
protected ArrayBlockingQueueDeserializer withResolved(JsonDeserializer<?> dd,
JsonDeserializer<?> vd, TypeDeserializer vtd, Boolean unwrapSingle)
{
if ((dd == _delegateDeserializer) && (vd == _valueDeserializer) && (vtd == _valueTypeDeserializer)
&& (_unwrapSingle == unwrapSingle)) {
return this;
}
return new ArrayBlockingQueueDeserializer(_collectionType,
(JsonDeserializer
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS><Object>) vd, vtd,
_valueInstantiator, (JsonDeserializer<Object>) dd, unwrapSingle);
}
/*
/**********************************************************
/* JsonDeserializer API
/**********************************************************
*/
@SuppressWarnings("unchecked")
@Override
public Collection<Object> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException
{
if (_delegateDeserializer != null) {
return (Collection<Object>) _valueInstantiator.createUsingDelegate(ctxt,
_delegateDeserializer.deserialize(jp, ctxt));
}
if (jp.getCurrentToken() == JsonToken.VALUE_STRING) {
String str = jp.getText();
if (str.length() == 0) {
return (Collection<Object>) _valueInstantiator.createFromString(ctxt, str);
}
}
return deserialize(jp, ctxt, null);
}
@Override
public Collection<Object> deserialize(JsonParser jp, DeserializationContext ctxt, Collection<Object> result0) throws IOException
{
// Ok: must point to START_ARRAY (or equivalent)
if (!jp.isExpectedStartArrayToken()) {
return handleNonArray(jp, ctxt, new ArrayBlockingQueue<Object>(1));
}
ArrayList<Object> tmp = new ArrayList<Object>();
JsonDeserializer<Object> valueDes = _valueDeserializer;
JsonToken t;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
try {
while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
Object value;
if (t == JsonToken.VALUE_NULL) {
value = valueDes.getNullValue(ctxt);
} else if (typeDeser == null) {
value = valueDes.deserialize(jp, ctxt);
} else {
value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
}
tmp.add(value);
}
} catch (Exception e) {
throw JsonMappingException.wrapWithPath(e, tmp, tmp.size());
}
if (result0 != null) {
result0.addAll(tmp);
return result0;
}
return new ArrayBlockingQueue<Object>(tmp.size(), false, tmp);
}
@Override
public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException {
// In
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.impl;
import java.io.IOException;
import java.lang.annotation.Annotation;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.deser.UnresolvedForwardReference;
import com.fasterxml.jackson.databind.deser.impl.ReadableObjectId.Referring;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
import com.fasterxml.jackson.databind.introspect.ObjectIdInfo;
public class ObjectIdReferenceProperty extends SettableBeanProperty
{
private static final long serialVersionUID = 1L;
private final SettableBeanProperty _forward;
public ObjectIdReferenceProperty(SettableBeanProperty forward, ObjectIdInfo objectIdInfo)
{
super(forward);
_forward = forward;
_objectIdInfo = objectIdInfo;
}
public ObjectIdReferenceProperty(ObjectIdReferenceProperty src, JsonDeserializer<?> deser)
{
super(src, deser);
_forward = src._forward;
_objectIdInfo = src._objectIdInfo;
}
public ObjectIdReferenceProperty(ObjectIdReferenceProperty src, PropertyName newName)
{
super(src, newName);
_forward = src._forward;
_objectIdInfo = src._objectIdInfo;
}
@Override
public SettableBeanProperty withValueDeserializer(JsonDeserializer<?> deser) {
return new ObjectIdReferenceProperty(this, deser);
}
@Override
public SettableBeanProperty withName(PropertyName newName) {
return new ObjectIdReferenceProperty(this, newName);
}
@Override
public void fixAccess(DeserializationConfig config) {
if (_forward != null) {
_forward.fixAccess(config);
}
}
@Override
public <A extends Annotation> A getAnnotation(Class<A> acls) {
return _forward.getAnnotation(acls);
}
@Override
public AnnotatedMember getMember() {
return _forward.getMember();
}
@Override
public int getCreatorIndex() {
return _forward.getCreatorIndex();
}
@Override
public void deserializeAndSet(JsonParser p, DeserializationContext ctxt, Object instance) throws IOException {
deserialize
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
@SuppressWarnings("rawtypes") // to work around JDK8 bug wrt Class-valued annotation properties
public Class<? extends JsonDeserializer> using()
default JsonDeserializer.None.class;
/**
* Deserializer class to use for deserializing contents (elements
* of a Collection/array, values of Maps) of annotated property.
* Can only be used on instances (methods, fields, constructors),
* and not value classes themselves.
*/
@SuppressWarnings("rawtypes") // to work around JDK8 bug wrt Class-valued annotation properties
public Class<? extends JsonDeserializer> contentUsing()
default JsonDeserializer.None.class;
/**
* Deserializer class to use for deserializing Map keys
* of annotated property.
* Can only be used on instances (methods, fields, constructors),
* and not value classes themselves.
*/
public Class<? extends KeyDeserializer> keyUsing()
default KeyDeserializer.None.class;
/**
* Annotation for specifying if an external Builder class is to
* be used for building up deserialized instances of annotated
* class. If so, an instance of referenced class is first constructed
* (possibly using a Creator method; or if none defined, using default
* constructor), and its "with-methods" are used for populating fields;
* and finally "build-method" is invoked to complete deserialization.
*/
public Class<?> builder() default Void.class;
// // // Annotations for specifying intermediate Converters (2.2+)
/**
* Which helper object (if any) is to be used to convert from Jackson-bound
* intermediate type (source type of converter) into actual property type
* (which must be same as result type of converter). This is often used
* for two-step deserialization; Jackson binds data into suitable intermediate
* type (like Tree representation), and converter then builds actual property
* type.
*
* @since 2.2
*/
@SuppressWarnings("rawtypes") // to work around JDK8 bug wrt Class-valued annotation properties
public Class<? extends Converter> converter() default Converter.None.class;
/**
* Similar to {@link #converter}, but used for values of structures types
* (List, arrays, Maps).
*
* @since 2.2
*/
@SuppressWarnings("rawtypes") // to
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> use
/**********************************************************
*/
protected JsonDeserializer<Object> _mapDeserializer;
protected JsonDeserializer<Object> _listDeserializer;
protected JsonDeserializer<Object> _stringDeserializer;
protected JsonDeserializer<Object> _numberDeserializer;
/**
* If {@link java.util.List} has been mapped to non-default implementation,
* we'll store type here
*
* @since 2.6
*/
protected JavaType _listType;
/**
* If {@link java.util.Map} has been mapped to non-default implementation,
* we'll store type here
*
* @since 2.6
*/
protected JavaType _mapType;
/**
* @deprecated Since 2.6 use variant takes type arguments
*/
@Deprecated
public UntypedObjectDeserializer() {
this(null, null);
}
public UntypedObjectDeserializer(JavaType listType, JavaType mapType) {
super(Object.class);
_listType = listType;
_mapType = mapType;
}
@SuppressWarnings("unchecked")
public UntypedObjectDeserializer(UntypedObjectDeserializer base,
JsonDeserializer<?> mapDeser, JsonDeserializer<?> listDeser,
JsonDeserializer<?> stringDeser, JsonDeserializer<?> numberDeser)
{
super(Object.class);
_mapDeserializer = (JsonDeserializer<Object>) mapDeser;
_listDeserializer = (JsonDeserializer<Object>) listDeser;
_stringDeserializer = (JsonDeserializer<Object>) stringDeser;
_numberDeserializer = (JsonDeserializer<Object>) numberDeser;
_listType = base._listType;
_mapType = base._mapType;
}
/*
/**********************************************************
/* Initialization
/**********************************************************
*/
/**
* We need to implement this method to properly find things to delegate
* to: it can not be done earlier since delegated deserializers almost
* certainly require access to this instance (at least "List" and "Map" ones)
*/
@SuppressWarnings("unchecked")
@Override
public void resolve(DeserializationContext ctxt) throws JsonMappingException
{
JavaType obType = ctxt.constructType(Object.class);
JavaType stringType = ctxt.constructType(String.class);
TypeFactory tf = ctxt.getTypeFactory();
/* 26-
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Nov-2014, tatu: This is highly unusual, as in general contextualization
* should always be called separately, from within "createContextual()".
* But this is a very singular deserializer since it operates on `Object`
* (and often for `?` type parameter), and as a result, easily and commonly
* results in cycles, being value deserializer for various Maps and Collections.
* Because of this, we must somehow break the cycles. This is done here by
* forcing pseudo-contextualization with null property.
*/
// So: first find possible custom instances
if (_listType == null) {
_listDeserializer = _clearIfStdImpl(_findCustomDeser(ctxt, tf.constructCollectionType(List.class, obType)));
} else {
// NOTE: if non-default List type, always consider to be non-standard deser
_listDeserializer = _findCustomDeser(ctxt, _listType);
}
if (_mapType == null) {
_mapDeserializer = _clearIfStdImpl(_findCustomDeser(ctxt, tf.constructMapType(Map.class, stringType, obType)));
} else {
// NOTE: if non-default Map type, always consider to be non-standard deser
_mapDeserializer = _findCustomDeser(ctxt, _mapType);
}
_stringDeserializer = _clearIfStdImpl(_findCustomDeser(ctxt, stringType));
_numberDeserializer = _clearIfStdImpl(_findCustomDeser(ctxt, tf.constructType(Number.class)));
// and then do bogus contextualization, in case custom ones need to resolve dependencies of
// their own
JavaType unknown = TypeFactory.unknownType();
_mapDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_mapDeserializer, null, unknown);
_listDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_listDeserializer, null, unknown);
_stringDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_stringDeserializer, null, unknown);
_numberDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_numberDeserializer, null, unknown);
}
protected JsonDeserializer<Object> _findCustomDeser(Deserialization
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Context ctxt, JavaType type)
throws JsonMappingException
{
// Since we are calling from `resolve`, we should NOT try to contextualize yet;
// contextualization will only occur at a later point
return ctxt.findNonContextualValueDeserializer(type);
}
protected JsonDeserializer<Object> _clearIfStdImpl(JsonDeserializer<Object> deser) {
return ClassUtil.isJacksonStdImpl(deser) ? null : deser;
}
/**
* We only use contextualization for optimizing the case where no customization
* occurred; if so, can slip in a more streamlined version.
*/
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
// 20-Apr-2014, tatu: If nothing custom, let's use "vanilla" instance,
// simpler and can avoid some of delegation
if ((_stringDeserializer == null) && (_numberDeserializer == null)
&& (_mapDeserializer == null) && (_listDeserializer == null)
&& getClass() == UntypedObjectDeserializer.class) {
return Vanilla.std;
}
return this;
}
protected JsonDeserializer<?> _withResolved(JsonDeserializer<?> mapDeser,
JsonDeserializer<?> listDeser,
JsonDeserializer<?> stringDeser, JsonDeserializer<?> numberDeser) {
return new UntypedObjectDeserializer(this,
mapDeser, listDeser, stringDeser, numberDeser);
}
/*
/**********************************************************
/* Deserializer API
/**********************************************************
*/
/* 07-Nov-2014, tatu: When investigating [databind#604], realized that it makes
* sense to also mark this is cachable, since lookup not exactly free, and
* since it's not uncommon to "read anything"
*/
@Override
public boolean isCachable() {
/* 26-Mar-2015, tatu: With respect to [databind#735], there are concerns over
* cachability. It seems like we SHOULD be safe here; but just in case there
* are problems with false sharing, this may need to be revisited.
*/
return true;
}
@
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.impl;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.introspect.AnnotatedField;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
import com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.Annotations;
import com.fasterxml.jackson.databind.util.ClassUtil;
/**
* This concrete sub-class implements property that is set
* directly assigning to a Field.
*/
public final class FieldProperty
extends SettableBeanProperty
{
private static final long serialVersionUID = 1L;
final protected AnnotatedField _annotated;
/**
* Actual field to set when deserializing this property.
* Transient since there is no need to persist; only needed during
* construction of objects.
*/
final protected transient Field _field;
public FieldProperty(BeanPropertyDefinition propDef, JavaType type,
TypeDeserializer typeDeser, Annotations contextAnnotations, AnnotatedField field)
{
super(propDef, type, typeDeser, contextAnnotations);
_annotated = field;
_field = field.getAnnotated();
}
protected FieldProperty(FieldProperty src, JsonDeserializer<?> deser) {
super(src, deser);
_annotated = src._annotated;
_field = src._field;
}
protected FieldProperty(FieldProperty src, PropertyName newName) {
super(src, newName);
_annotated = src._annotated;
_field = src._field;
}
/**
* Constructor used for JDK Serialization when reading persisted object
*/
protected FieldProperty(FieldProperty src)
{
super(src);
_annotated = src._annotated;
Field f = _annotated.getAnnotated();
if (f == null) {
throw new IllegalArgumentException("Missing field (broken JDK (de)serialization?)");
}
_field = f;
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
@Override
public FieldProperty withName(PropertyName newName) {
return new FieldProperty(this, newName);
}
@Override
public FieldProperty withValueDeserializer(JsonDeserializer<?> deser) {
return new FieldProperty(this, deser);
}
@Override
public void fixAccess(DeserializationConfig config) {
ClassUtil.checkAndFixAccess(_field,
config.isEnabled(MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS));
}
/*
/**********************************************************
/* BeanProperty impl
/**********************************************************
*/
@Override
public <A extends Annotation> A getAnnotation(Class<A> acls) {
return (_annotated == null) ? null : _annotated.getAnnotation(acls);
}
@Override public AnnotatedMember getMember() { return _annotated; }
/*
/**********************************************************
/* Overridden methods
/**********************************************************
*/
@Override
public void deserializeAndSet(JsonParser p,
DeserializationContext ctxt, Object instance) throws IOException
{
Object value = deserialize(p, ctxt);
try {
_field.set(instance, value);
} catch (Exception e) {
_throwAsIOE(p, e, value);
}
}
@Override
public Object deserializeSetAndReturn(JsonParser p,
DeserializationContext ctxt, Object instance) throws IOException
{
Object value = deserialize(p, ctxt);
try {
_field.set(instance, value);
} catch (Exception e) {
_throwAsIOE(p, e, value);
}
return instance;
}
@Override
public final void set(Object instance, Object value) throws IOException
{
try {
_field.set(instance, value);
} catch (Exception e) {
// 15-Sep-2015, tatu: How could we get a ref to JsonParser?
_throwAsIOE(e, value);
}
}
@Override
public Object setAndReturn(Object instance, Object value) throws IOException
{
try {
_field.set(instance, value);
} catch (Exception e) {
// 15-Sep-2015, tatu: How could we get a ref to JsonParser?
_throwAsIOE(e, value);
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.ext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.PropertyName;
import com.fasterxml.jackson.databind.introspect.Annotated;
import com.fasterxml.jackson.databind.introspect.AnnotatedParameter;
/**
* To support Java7-incomplete platforms, we will offer support for JDK 7
* annotations through this class, loaded dynamically; if loading fails,
* support will be missing. This class is the non-JDK-7-dependent API,
* and {@link Java7SupportImpl} is JDK7-dependent implementation of
* functionality.
*/
public abstract class Java7Support
{
private final static Java7Support IMPL;
static {
Java7Support impl = null;
try {
Class<?> cls = Class.forName("com.fasterxml.jackson.databind.ext.Java7SupportImpl");
impl = (Java7Support) cls.newInstance();
} catch (Throwable t) {
// 24-Nov-2015, tatu: Should we log or not?
java.util.logging.Logger.getLogger(Java7Support.class.getName())
.warning("Unable to load JDK7 types (annotations, java.nio.file.Path): no Java7 support added");
}
IMPL = impl;
}
public static Java7Support instance() {
return IMPL;
}
public abstract Boolean findTransient(Annotated a);
public abstract Boolean hasCreatorAnnotation(Annotated a);
public abstract PropertyName findConstructorName(AnnotatedParameter p);
public abstract Class<?> getClassJavaNioFilePath();
public abstract JsonDeserializer<?> getDeserializerForJavaNioFilePath(Class<?> rawType);
public abstract JsonSerializer<?> getSerializerForJavaNioFilePath(Class<?> rawType);
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> low concurrency setting.
*<p>
* Since version 1.5, these may are either "raw" deserializers (when
* no type information is needed for base type), or type-wrapped
* deserializers (if it is needed)
*/
final protected ConcurrentHashMap<JavaType, JsonDeserializer<Object>> _rootDeserializers
= new ConcurrentHashMap<JavaType, JsonDeserializer<Object>>(64, 0.6f, 2);
/*
/**********************************************************
/* Life-cycle: constructing instance
/**********************************************************
*/
/**
* Default constructor, which will construct the default
* {@link JsonFactory} as necessary, use
* {@link SerializerProvider} as its
* {@link SerializerProvider}, and
* {@link BeanSerializerFactory} as its
* {@link SerializerFactory}.
* This means that it
* can serialize all standard JDK types, as well as regular
* Java Beans (based on method names and Jackson-specific annotations),
* but does not support JAXB annotations.
*/
public ObjectMapper() {
this(null, null, null);
}
/**
* Constructs instance that uses specified {@link JsonFactory}
* for constructing necessary {@link JsonParser}s and/or
* {@link JsonGenerator}s.
*/
public ObjectMapper(JsonFactory jf) {
this(jf, null, null);
}
/**
* Copy-constructor, mostly used to support {@link #copy}.
*
* @since 2.1
*/
protected ObjectMapper(ObjectMapper src)
{
_jsonFactory = src._jsonFactory.copy();
_jsonFactory.setCodec(this);
_subtypeResolver = src._subtypeResolver;
_typeFactory = src._typeFactory;
_injectableValues = src._injectableValues;
_propertyOverrides = src._propertyOverrides.copy();
_mixIns = src._mixIns.copy();
RootNameLookup rootNames = new RootNameLookup();
_serializationConfig = new SerializationConfig(src._serializationConfig, _mixIns, rootNames, _propertyOverrides);
_deserializationConfig = new DeserializationConfig(src._deserializationConfig, _mixIns, rootNames, _propertyOverrides);
_serializerProvider = src._serializerProvider.copy();
_deserializationContext = src._deserializationContext.copy();
//
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
*<p>
* Type-safe overload of {@link #readValues(JsonParser, ResolvedType)}.
*/
public <T> MappingIterator<T> readValues(JsonParser p, JavaType valueType)
throws IOException, JsonProcessingException
{
DeserializationConfig config = getDeserializationConfig();
DeserializationContext ctxt = createDeserializationContext(p, config);
JsonDeserializer<?> deser = _findRootDeserializer(ctxt, valueType);
// false -> do NOT close JsonParser (since caller passed it)
return new MappingIterator<T>(valueType, p, ctxt, deser,
false, null);
}
/**
* Convenience method, equivalent in function to:
*<pre>
* readerFor(valueType).readValues(p);
*</pre>
*<p>
* Type-safe overload of {@link #readValues(JsonParser, ResolvedType)}.
*/
@Override
public <T> MappingIterator<T> readValues(JsonParser p, Class<T> valueType)
throws IOException, JsonProcessingException
{
return readValues(p, _typeFactory.constructType(valueType));
}
/**
* Method for reading sequence of Objects from parser stream.
*/
@Override
public <T> MappingIterator<T> readValues(JsonParser p, TypeReference<?> valueTypeRef)
throws IOException, JsonProcessingException
{
return readValues(p, _typeFactory.constructType(valueTypeRef));
}
/*
/**********************************************************
/* Public API not included in ObjectCodec: deserialization
/* (mapping from JSON to Java types)
/**********************************************************
*/
/**
* Method to deserialize JSON content as tree expressed
* using set of {@link JsonNode} instances.
* Returns root of the resulting tree (where root can consist
* of just a single node if the current event is a
* value event, not container).
*<p>
* If a low-level I/O problem (missing input, network error) occurs,
* a {@link IOException} will be thrown.
* If a parsing problem occurs (invalid JSON),
* {@link JsonParseException} will be thrown.
* If no content is found from input (end-of-input), Java
* <code>null</code> will be returned.
*
* @param in Input stream used
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> */
@SuppressWarnings("resource")
protected Object _convert(Object fromValue, JavaType toValueType)
throws IllegalArgumentException
{
// also, as per [databind#11], consider case for simple cast
/* But with caveats: one is that while everything is Object.class, we don't
* want to "optimize" that out; and the other is that we also do not want
* to lose conversions of generic types.
*/
Class<?> targetType = toValueType.getRawClass();
if (targetType != Object.class
&& !toValueType.hasGenericTypes()
&& targetType.isAssignableFrom(fromValue.getClass())) {
return fromValue;
}
// Then use TokenBuffer, which is a JsonGenerator:
TokenBuffer buf = new TokenBuffer(this, false);
if (isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
buf = buf.forceUseOfBigDecimal(true);
}
try {
// inlined 'writeValue' with minor changes:
// first: disable wrapping when writing
SerializationConfig config = getSerializationConfig().without(SerializationFeature.WRAP_ROOT_VALUE);
// no need to check for closing of TokenBuffer
_serializerProvider(config).serializeValue(buf, fromValue);
// then matching read, inlined 'readValue' with minor mods:
final JsonParser p = buf.asParser();
Object result;
// ok to pass in existing feature flags; unwrapping handled by mapper
final DeserializationConfig deserConfig = getDeserializationConfig();
JsonToken t = _initForReading(p);
if (t == JsonToken.VALUE_NULL) {
DeserializationContext ctxt = createDeserializationContext(p, deserConfig);
result = _findRootDeserializer(ctxt, toValueType).getNullValue(ctxt);
} else if (t == JsonToken.END_ARRAY || t == JsonToken.END_OBJECT) {
result = null;
} else { // pointing to event other than null
DeserializationContext ctxt = createDeserializationContext(p, deserConfig);
JsonDeserializer<Object> deser = _findRootDeserializer(ctxt, toValueType);
// note: no handling of unwrapping
result = deser.deserialize(p, ctxt);
}
p.close();
return result;
} catch (IOException e) { // should not occur, no real i
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> g.flush();
}
} catch (Exception e) {
ClassUtil.closeOnFailAndThrowAsIAE(null, toClose, e);
return;
}
toClose.close();
}
/*
/**********************************************************
/* Internal methods for deserialization, overridable
/**********************************************************
*/
/**
* Internal helper method called to create an instance of {@link DeserializationContext}
* for deserializing a single root value.
* Can be overridden if a custom context is needed.
*/
protected DefaultDeserializationContext createDeserializationContext(JsonParser p,
DeserializationConfig cfg) {
return _deserializationContext.createInstance(cfg, p, _injectableValues);
}
/**
* Actual implementation of value reading+binding operation.
*/
protected Object _readValue(DeserializationConfig cfg, JsonParser p, JavaType valueType)
throws IOException
{
/* First: may need to read the next token, to initialize
* state (either before first read from parser, or after
* previous token has been cleared)
*/
Object result;
JsonToken t = _initForReading(p);
if (t == JsonToken.VALUE_NULL) {
// Ask JsonDeserializer what 'null value' to use:
DeserializationContext ctxt = createDeserializationContext(p, cfg);
result = _findRootDeserializer(ctxt, valueType).getNullValue(ctxt);
} else if (t == JsonToken.END_ARRAY || t == JsonToken.END_OBJECT) {
result = null;
} else { // pointing to event other than null
DeserializationContext ctxt = createDeserializationContext(p, cfg);
JsonDeserializer<Object> deser = _findRootDeserializer(ctxt, valueType);
// ok, let's get the value
if (cfg.useRootWrapping()) {
result = _unwrapAndDeserialize(p, ctxt, cfg, valueType, deser);
} else {
result = deser.deserialize(p, ctxt);
}
}
// Need to consume the token too
p.clearCurrentToken();
return result;
}
protected Object _readMapAndClose(JsonParser p0, JavaType valueType)
throws IOException
{
try (JsonParser p = p0) {
Object result;
JsonToken t = _initForReading(p);
if (
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>t == JsonToken.VALUE_NULL) {
// Ask JsonDeserializer what 'null value' to use:
DeserializationContext ctxt = createDeserializationContext(p,
getDeserializationConfig());
result = _findRootDeserializer(ctxt, valueType).getNullValue(ctxt);
} else if (t == JsonToken.END_ARRAY || t == JsonToken.END_OBJECT) {
result = null;
} else {
DeserializationConfig cfg = getDeserializationConfig();
DeserializationContext ctxt = createDeserializationContext(p, cfg);
JsonDeserializer<Object> deser = _findRootDeserializer(ctxt, valueType);
if (cfg.useRootWrapping()) {
result = _unwrapAndDeserialize(p, ctxt, cfg, valueType, deser);
} else {
result = deser.deserialize(p, ctxt);
}
ctxt.checkUnresolvedObjectId();
}
// Need to consume the token too
p.clearCurrentToken();
return result;
}
}
/**
* Method called to ensure that given parser is ready for reading
* content for data binding.
*
* @return First token to be used for data binding after this call:
* can never be null as exception will be thrown if parser can not
* provide more tokens.
*
* @throws IOException if the underlying input source has problems during
* parsing
* @throws JsonParseException if parser has problems parsing content
* @throws JsonMappingException if the parser does not have any more
* content to map (note: Json "null" value is considered content;
* enf-of-stream not)
*/
protected JsonToken _initForReading(JsonParser p) throws IOException
{
_deserializationConfig.initialize(p); // since 2.5
/* First: must point to a token; if not pointing to one, advance.
* This occurs before first read from JsonParser, as well as
* after clearing of current token.
*/
JsonToken t = p.getCurrentToken();
if (t == null) {
// and then we must get something...
t = p.nextToken();
if (t == null) {
// Throw mapping exception, since it's failure to map,
// not an actual parsing problem
throw JsonMappingException.from(p, "No content to map due to end
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>-of-input");
}
}
return t;
}
protected Object _unwrapAndDeserialize(JsonParser p, DeserializationContext ctxt,
DeserializationConfig config,
JavaType rootType, JsonDeserializer<Object> deser)
throws IOException
{
PropertyName expRootName = config.findRootName(rootType);
// 12-Jun-2015, tatu: Should try to support namespaces etc but...
String expSimpleName = expRootName.getSimpleName();
if (p.getCurrentToken() != JsonToken.START_OBJECT) {
ctxt.reportWrongTokenException(p, JsonToken.START_OBJECT,
"Current token not START_OBJECT (needed to unwrap root name '%s'), but %s",
expSimpleName, p.getCurrentToken());
}
if (p.nextToken() != JsonToken.FIELD_NAME) {
ctxt.reportWrongTokenException(p, JsonToken.FIELD_NAME,
"Current token not FIELD_NAME (to contain expected root name '"
+expSimpleName+"'), but "+p.getCurrentToken());
}
String actualName = p.getCurrentName();
if (!expSimpleName.equals(actualName)) {
ctxt.reportMappingException("Root name '%s' does not match expected ('%s') for type %s",
actualName, expSimpleName, rootType);
}
// ok, then move to value itself....
p.nextToken();
Object result = deser.deserialize(p, ctxt);
// and last, verify that we now get matching END_OBJECT
if (p.nextToken() != JsonToken.END_OBJECT) {
ctxt.reportWrongTokenException(p, JsonToken.END_OBJECT,
"Current token not END_OBJECT (to match wrapper object with root name '%s'), but %s",
expSimpleName, p.getCurrentToken());
}
return result;
}
/*
/**********************************************************
/* Internal methods, other
/**********************************************************
*/
/**
* Method called to locate deserializer for the passed root-level value.
*/
protected JsonDeserializer<Object> _findRootDeserializer(DeserializationContext ctxt,
JavaType valueType)
throws JsonMappingException
{
// First: have we already seen it?
JsonDeserializer<Object> deser = _rootDeserializers.get(valueType);
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
if (deser != null) {
return deser;
}
// Nope: need to ask provider to resolve it
deser = ctxt.findRootValueDeserializer(valueType);
if (deser == null) { // can this happen?
throw JsonMappingException.from(ctxt,
"Can not find a deserializer for type "+valueType);
}
_rootDeserializers.put(valueType, deser);
return deser;
}
/**
* @since 2.2
*/
protected void _verifySchemaType(FormatSchema schema)
{
if (schema != null) {
if (!_jsonFactory.canUseSchema(schema)) {
throw new IllegalArgumentException("Can not use FormatSchema of type "+schema.getClass().getName()
+" for format "+_jsonFactory.getFormatName());
}
}
}
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
if (pann != null) {
return PropertyName.construct(pann.value());
}
if (_hasOneOf(a, ANNOTATIONS_TO_INFER_SER)) {
return PropertyName.USE_DEFAULT;
}
return null;
}
@Override
public boolean hasAsValueAnnotation(AnnotatedMethod am) {
JsonValue ann = _findAnnotation(am, JsonValue.class);
// value of 'false' means disabled...
return (ann != null && ann.value());
}
/*
/**********************************************************
/* Deserialization: general annotations
/**********************************************************
*/
@Override
public Object findDeserializer(Annotated a)
{
JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class);
if (ann != null) {
@SuppressWarnings("rawtypes")
Class<? extends JsonDeserializer> deserClass = ann.using();
if (deserClass != JsonDeserializer.None.class) {
return deserClass;
}
}
return null;
}
@Override
public Object findKeyDeserializer(Annotated a)
{
JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class);
if (ann != null) {
Class<? extends KeyDeserializer> deserClass = ann.keyUsing();
if (deserClass != KeyDeserializer.None.class) {
return deserClass;
}
}
return null;
}
@Override
public Object findContentDeserializer(Annotated a)
{
JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class);
if (ann != null) {
@SuppressWarnings("rawtypes")
Class<? extends JsonDeserializer> deserClass = ann.contentUsing();
if (deserClass != JsonDeserializer.None.class) {
return deserClass;
}
}
return null;
}
@Override
public Object findDeserializationConverter(Annotated a)
{
JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class);
return (ann == null) ? null : _classIfExplicit(ann.converter(), Converter.None.class);
}
@Override
public Object findDeserializationContentConverter(AnnotatedMember a)
{
JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class);
return (ann == null) ? null : _classIfExplicit(ann.contentConverter(),
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> binary content.
* Same as calling:
*<pre>
* getConfig().getBase64Variant();
*</pre>
*/
public final Base64Variant getBase64Variant() {
return _config.getBase64Variant();
}
/**
* Convenience method, functionally equivalent to:
*<pre>
* getConfig().getNodeFactory();
* </pre>
*/
public final JsonNodeFactory getNodeFactory() {
return _config.getNodeFactory();
}
/*
/**********************************************************
/* Public API, pass-through to DeserializerCache
/**********************************************************
*/
/**
* Method for checking whether we could find a deserializer
* for given type.
*
* @param type
* @since 2.3
*/
public boolean hasValueDeserializerFor(JavaType type, AtomicReference<Throwable> cause) {
try {
return _cache.hasValueDeserializerFor(this, _factory, type);
} catch (JsonMappingException e) {
if (cause != null) {
cause.set(e);
}
} catch (RuntimeException e) {
if (cause == null) { // earlier behavior
throw e;
}
cause.set(e);
}
return false;
}
/**
* Method for finding a value deserializer, and creating a contextual
* version if necessary, for value reached via specified property.
*/
@SuppressWarnings("unchecked")
public final JsonDeserializer<Object> findContextualValueDeserializer(JavaType type,
BeanProperty prop) throws JsonMappingException
{
JsonDeserializer<Object> deser = _cache.findValueDeserializer(this, _factory, type);
if (deser != null) {
deser = (JsonDeserializer<Object>) handleSecondaryContextualization(deser, prop, type);
}
return deser;
}
/**
* Variant that will try to locate deserializer for current type, but without
* performing any contextualization (unlike {@link #findContextualValueDeserializer})
* or checking for need to create a {@link TypeDeserializer} (unlike
* {@link #findRootValueDeserializer(JavaType)}.
* This method is usually called from within {@link ResolvableDeserializer#resolve},
* and expectation is that caller then calls either
* {@link #handlePrimaryContextualization(JsonDeserializer
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>, BeanProperty, JavaType)} or
* {@link #handleSecondaryContextualization(JsonDeserializer, BeanProperty, JavaType)} at a
* later point, as necessary.
*
* @since 2.5
*/
public final JsonDeserializer<Object> findNonContextualValueDeserializer(JavaType type)
throws JsonMappingException
{
return _cache.findValueDeserializer(this, _factory, type);
}
/**
* Method for finding a deserializer for root-level value.
*/
@SuppressWarnings("unchecked")
public final JsonDeserializer<Object> findRootValueDeserializer(JavaType type)
throws JsonMappingException
{
JsonDeserializer<Object> deser = _cache.findValueDeserializer(this,
_factory, type);
if (deser == null) { // can this occur?
return null;
}
deser = (JsonDeserializer<Object>) handleSecondaryContextualization(deser, null, type);
TypeDeserializer typeDeser = _factory.findTypeDeserializer(_config, type);
if (typeDeser != null) {
// important: contextualize to indicate this is for root value
typeDeser = typeDeser.forProperty(null);
return new TypeWrappedDeserializer(typeDeser, deser);
}
return deser;
}
/**
* Convenience method, functionally same as:
*<pre>
* getDeserializerProvider().findKeyDeserializer(getConfig(), prop.getType(), prop);
*</pre>
*/
public final KeyDeserializer findKeyDeserializer(JavaType keyType,
BeanProperty prop) throws JsonMappingException {
KeyDeserializer kd = _cache.findKeyDeserializer(this,
_factory, keyType);
// Second: contextualize?
if (kd instanceof ContextualKeyDeserializer) {
kd = ((ContextualKeyDeserializer) kd).createContextual(this, prop);
}
return kd;
}
/*
/**********************************************************
/* Public API, ObjectId handling
/**********************************************************
*/
/**
* Method called to find and return entry corresponding to given
* Object Id: will add an entry if necessary, and never returns null
*/
public abstract ReadableObjectId findObjectId(Object id, ObjectIdGenerator<?> generator, ObjectIdResolver resolver);
/**
* Method called to ensure that every object id encounter during processing
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> == null) {
_arrayBuilders = new ArrayBuilders();
}
return _arrayBuilders;
}
/*
/**********************************************************
/* Extended API: handler instantiation
/**********************************************************
*/
public abstract JsonDeserializer<Object> deserializerInstance(Annotated annotated,
Object deserDef)
throws JsonMappingException;
public abstract KeyDeserializer keyDeserializerInstance(Annotated annotated,
Object deserDef)
throws JsonMappingException;
/*
/**********************************************************
/* Extended API: resolving contextual deserializers; called
/* by structured deserializers for their value/component
/* deserializers
/**********************************************************
*/
/**
* Method called for primary property deserializers (ones
* directly created to deserialize values of a POJO property),
* to handle details of resolving
* {@link ContextualDeserializer} with given property context.
*
* @param prop Property for which the given primary deserializer is used; never null.
*
* @since 2.5
*/
public JsonDeserializer<?> handlePrimaryContextualization(JsonDeserializer<?> deser,
BeanProperty prop, JavaType type)
throws JsonMappingException
{
if (deser instanceof ContextualDeserializer) {
_currentType = new LinkedNode<JavaType>(type, _currentType);
try {
deser = ((ContextualDeserializer) deser).createContextual(this, prop);
} finally {
_currentType = _currentType.next();
}
}
return deser;
}
/**
* Method called for secondary property deserializers (ones
* NOT directly created to deal with an annotatable POJO property,
* but instead created as a component -- such as value deserializers
* for structured types, or deserializers for root values)
* to handle details of resolving
* {@link ContextualDeserializer} with given property context.
* Given that these deserializers are not directly related to given property
* (or, in case of root value property, to any property), annotations
* accessible may or may not be relevant.
*
* @param prop Property for which deserializer is used, if any; null
* when deserializing root values
*
* @since 2.5
*/
public JsonDeserializer<?> handleSecondaryContextualization(JsonDeserializer<?> deser,
BeanProperty prop, JavaType type)
throws JsonMappingException
{
if (deser instanceof
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> ContextualDeserializer) {
_currentType = new LinkedNode<JavaType>(type, _currentType);
try {
deser = ((ContextualDeserializer) deser).createContextual(this, prop);
} finally {
_currentType = _currentType.next();
}
}
return deser;
}
@Deprecated // since 2.5; remove from 2.9
public JsonDeserializer<?> handlePrimaryContextualization(JsonDeserializer<?> deser, BeanProperty prop) throws JsonMappingException {
return handlePrimaryContextualization(deser, prop, TypeFactory.unknownType());
}
@Deprecated // since 2.5; remove from 2.9
public JsonDeserializer<?> handleSecondaryContextualization(JsonDeserializer<?> deser, BeanProperty prop) throws JsonMappingException {
if (deser instanceof ContextualDeserializer) {
deser = ((ContextualDeserializer) deser).createContextual(this, prop);
}
return deser;
}
/*
/**********************************************************
/* Parsing methods that may use reusable/-cyclable objects
/**********************************************************
*/
/**
* Convenience method for parsing a Date from given String, using
* currently configured date format (accessed using
* {@link DeserializationConfig#getDateFormat()}).
*<p>
* Implementation will handle thread-safety issues related to
* date formats such that first time this method is called,
* date format is cloned, and cloned instance will be retained
* for use during this deserialization round.
*/
public Date parseDate(String dateStr) throws IllegalArgumentException
{
try {
DateFormat df = getDateFormat();
return df.parse(dateStr);
} catch (ParseException e) {
throw new IllegalArgumentException(String.format(
"Failed to parse Date value '%s': %s", dateStr, e.getMessage()));
}
}
/**
* Convenience method for constructing Calendar instance set
* to specified time, to be modified and used by caller.
*/
public Calendar constructCalendar(Date d) {
// 08-Jan-2008, tatu: not optimal, but should work for the most part; let's revise as needed.
Calendar c = Calendar.getInstance(getTimeZone());
c.setTime(d);
return c;
}
/*
/**********************************************************
/* Convenience methods for reading parsed values
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
/**********************************************************
*/
/**
* Convenience method that may be used by composite or container deserializers,
* for reading one-off values contained (for sequences, it is more efficient
* to actually fetch deserializer once for the whole collection).
*<p>
* NOTE: when deserializing values of properties contained in composite types,
* rather use {@link #readPropertyValue(JsonParser, BeanProperty, Class)};
* this method does not allow use of contextual annotations.
*
* @since 2.4
*/
public <T> T readValue(JsonParser p, Class<T> type) throws IOException {
return readValue(p, getTypeFactory().constructType(type));
}
/**
* @since 2.4
*/
@SuppressWarnings("unchecked")
public <T> T readValue(JsonParser p, JavaType type) throws IOException {
JsonDeserializer<Object> deser = findRootValueDeserializer(type);
if (deser == null) {
reportMappingException("Could not find JsonDeserializer for type %s", type);
}
return (T) deser.deserialize(p, this);
}
/**
* Convenience method that may be used by composite or container deserializers,
* for reading one-off values for the composite type, taking into account
* annotations that the property (passed to this method -- usually property that
* has custom serializer that called this method) has.
*
* @since 2.4
*/
public <T> T readPropertyValue(JsonParser p, BeanProperty prop, Class<T> type) throws IOException {
return readPropertyValue(p, prop, getTypeFactory().constructType(type));
}
/**
* @since 2.4
*/
@SuppressWarnings("unchecked")
public <T> T readPropertyValue(JsonParser p, BeanProperty prop, JavaType type) throws IOException {
JsonDeserializer<Object> deser = findContextualValueDeserializer(type, prop);
if (deser == null) {
String propName = (prop == null) ? "NULL" : ("'"+prop.getName()+"'");
reportMappingException(
"Could not find JsonDeserializer for type %s (via property %s)",
type, propName);
}
return (T) deser.deserialize(p, this);
}
/*
/
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>**********************************************************
/* Methods for problem handling
/**********************************************************
*/
/**
* Method that deserializers should call if they encounter an unrecognized
* property (and once that is not explicitly designed as ignorable), to
* inform possibly configured {@link DeserializationProblemHandler}s and
* let it handle the problem.
*
* @return True if there was a configured problem handler that was able to handle the
* problem
*/
public boolean handleUnknownProperty(JsonParser p, JsonDeserializer<?> deser,
Object instanceOrClass, String propName)
throws IOException
{
LinkedNode<DeserializationProblemHandler> h = _config.getProblemHandlers();
while (h != null) {
// Can bail out if it's handled
if (h.value().handleUnknownProperty(this, p, deser, instanceOrClass, propName)) {
return true;
}
h = h.next();
}
// Nope, not handled. Potentially that's a problem...
if (!isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)) {
p.skipChildren();
return true;
}
// Do we know properties that are expected instead?
Collection<Object> propIds = (deser == null) ? null : deser.getKnownPropertyNames();
throw UnrecognizedPropertyException.from(_parser,
instanceOrClass, propName, propIds);
}
/**
* Method that deserializers should call if they encounter a String value
* that can not be converted to expected key of a {@link java.util.Map}
* valued property.
* Default implementation will try to call {@link DeserializationProblemHandler#handleWeirdNumberValue}
* on configured handlers, if any, to allow for recovery; if recovery does not
* succeed, will throw {@link InvalidFormatException} with given message.
*
* @param keyClass Expected type for key
* @param keyValue String value from which to deserialize key
* @param msg Error message template caller wants to use if exception is to be thrown
* @param msgArgs Optional arguments to use for message, if any
*
* @return Key value to use
*
* @throws IOException To indicate unrecoverable problem, usually based on <code>msg</code>
*
* @since 2.8
*/
public Object handleWeirdKey
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>_INVALID_SUBTYPE)) {
return null;
}
throw unknownTypeIdException(baseType, id, extraDesc);
}
/*
/**********************************************************
/* Methods for problem reporting, in cases where recovery
/* is not considered possible
/**********************************************************
*/
/**
* Method for deserializers to call
* when the token encountered was of type different than what <b>should</b>
* be seen at that position, usually within a sequence of expected tokens.
* Note that this method will throw a {@link JsonMappingException} and no
* recovery is attempted (via {@link DeserializationProblemHandler}, as
* problem is considered to be difficult to recover from, in general.
*
* @since 2.8
*/
public void reportWrongTokenException(JsonParser p,
JsonToken expToken, String msg, Object... msgArgs)
throws JsonMappingException
{
if ((msg != null) && (msgArgs.length > 0)) {
msg = String.format(msg, msgArgs);
}
throw wrongTokenException(p, expToken, msg);
}
/**
* Helper method for reporting a problem with unhandled unknown property.
*
* @param instanceOrClass Either value being populated (if one has been
* instantiated), or Class that indicates type that would be (or
* have been) instantiated
* @param deser Deserializer that had the problem, if called by deserializer
* (or on behalf of one)
*
* @deprecated Since 2.8 call {@link #handleUnknownProperty} instead
*/
@Deprecated
public void reportUnknownProperty(Object instanceOrClass, String fieldName,
JsonDeserializer<?> deser)
throws JsonMappingException
{
if (!isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)) {
return;
}
// Do we know properties that are expected instead?
Collection<Object> propIds = (deser == null) ? null : deser.getKnownPropertyNames();
throw UnrecognizedPropertyException.from(_parser,
instanceOrClass, fieldName, propIds);
}
/**
* @since 2.8
*/
public void reportMappingException(String msg, Object... msgArgs)
throws JsonMappingException
{
if (msgArgs.length > 0) {
msg = String.format
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.impl;
import java.io.IOException;
import java.util.Set;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.*;
import com.fasterxml.jackson.databind.util.NameTransformer;
/**
* Variant of {@link BeanDeserializer} used for handling deserialization
* of POJOs when serialized as JSON Arrays, instead of JSON Objects.
*
* @since 2.1
*/
public class BeanAsArrayDeserializer
extends BeanDeserializerBase
{
private static final long serialVersionUID = 1L;
/**
* Deserializer we delegate operations that we can not handle.
*/
protected final BeanDeserializerBase _delegate;
/**
* Properties in order expected to be found in JSON array.
*/
protected final SettableBeanProperty[] _orderedProperties;
/*
/**********************************************************
/* Life-cycle, construction, initialization
/**********************************************************
*/
/**
* Main constructor used both for creating new instances (by
* {@link BeanDeserializer#asArrayDeserializer}) and for
* creating copies with different delegate.
*/
public BeanAsArrayDeserializer(BeanDeserializerBase delegate,
SettableBeanProperty[] ordered)
{
super(delegate);
_delegate = delegate;
_orderedProperties = ordered;
}
@Override
public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper)
{
/* We can't do much about this; could either replace _delegate
* with unwrapping instance, or just replace this one. Latter seems
* more sensible.
*/
return _delegate.unwrappingDeserializer(unwrapper);
}
@Override
public BeanDeserializerBase withObjectIdReader(ObjectIdReader oir) {
return new BeanAsArrayDeserializer(_delegate.withObjectIdReader(oir),
_orderedProperties);
}
@Override
public BeanDeserializerBase withIgnorableProperties(Set<String> ignorableProps) {
return new BeanAsArrayDeserializer(_delegate.withIgnorableProperties(ignorableProps),
_orderedProperties);
}
@Override
public BeanDeserializerBase withBeanProperties(BeanPropertyMap props) {
return new BeanAsArrayDeserializer(_delegate
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>5;
public final static int TYPE_CURRENCY = 16;
final protected int _kind;
final protected Class<?> _keyClass;
/**
* Some types that are deserialized using a helper deserializer.
*/
protected final FromStringDeserializer<?> _deser;
protected StdKeyDeserializer(int kind, Class<?> cls) {
this(kind, cls, null);
}
protected StdKeyDeserializer(int kind, Class<?> cls, FromStringDeserializer<?> deser) {
_kind = kind;
_keyClass = cls;
_deser = deser;
}
public static StdKeyDeserializer forType(Class<?> raw)
{
int kind;
// first common types:
if (raw == String.class || raw == Object.class) {
return StringKD.forType(raw);
} else if (raw == UUID.class) {
kind = TYPE_UUID;
} else if (raw == Integer.class) {
kind = TYPE_INT;
} else if (raw == Long.class) {
kind = TYPE_LONG;
} else if (raw == Date.class) {
kind = TYPE_DATE;
} else if (raw == Calendar.class) {
kind = TYPE_CALENDAR;
// then less common ones...
} else if (raw == Boolean.class) {
kind = TYPE_BOOLEAN;
} else if (raw == Byte.class) {
kind = TYPE_BYTE;
} else if (raw == Character.class) {
kind = TYPE_CHAR;
} else if (raw == Short.class) {
kind = TYPE_SHORT;
} else if (raw == Float.class) {
kind = TYPE_FLOAT;
} else if (raw == Double.class) {
kind = TYPE_DOUBLE;
} else if (raw == URI.class) {
kind = TYPE_URI;
} else if (raw == URL.class) {
kind = TYPE_URL;
} else if (raw == Class.class) {
kind = TYPE_CLASS;
} else if (raw == Locale.class) {
FromStringDeserializer<?> deser = FromStringDeserializer.findDeserializer(Locale.class);
return new StdKeyDeserializer(TYPE_LOCALE, raw, deser);
} else if (raw == Currency.
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>class) {
FromStringDeserializer<?> deser = FromStringDeserializer.findDeserializer(Currency.class);
return new StdKeyDeserializer(TYPE_CURRENCY, raw, deser);
} else {
return null;
}
return new StdKeyDeserializer(kind, raw);
}
@Override
public Object deserializeKey(String key, DeserializationContext ctxt)
throws IOException
{
if (key == null) { // is this even legal call?
return null;
}
try {
Object result = _parse(key, ctxt);
if (result != null) {
return result;
}
} catch (Exception re) {
return ctxt.handleWeirdKey(_keyClass, key, "not a valid representation, problem: (%s) %s",
re.getClass().getName(), re.getMessage());
}
if (_keyClass.isEnum() && ctxt.getConfig().isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) {
return null;
}
return ctxt.handleWeirdKey(_keyClass, key, "not a valid representation");
}
public Class<?> getKeyClass() { return _keyClass; }
protected Object _parse(String key, DeserializationContext ctxt) throws Exception
{
switch (_kind) {
case TYPE_BOOLEAN:
if ("true".equals(key)) {
return Boolean.TRUE;
}
if ("false".equals(key)) {
return Boolean.FALSE;
}
return ctxt.handleWeirdKey(_keyClass, key, "value not 'true' or 'false'");
case TYPE_BYTE:
{
int value = _parseInt(key);
// allow range up to 255, inclusive (to support "unsigned" byte)
if (value < Byte.MIN_VALUE || value > 255) {
return ctxt.handleWeirdKey(_keyClass, key, "overflow, value can not be represented as 8-bit value");
}
return Byte.valueOf((byte) value);
}
case TYPE_SHORT:
{
int value = _parseInt(key);
if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
return ctxt.handleWeirdKey(_keyClass, key, "overflow, value can not be represented as 16-bit
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>WeirdKey(_keyClass, key, "unable to parse key as Class");
}
default:
throw new IllegalStateException("Internal error: unknown key type "+_keyClass);
}
}
/*
/**********************************************************
/* Helper methods for sub-classes
/**********************************************************
*/
protected int _parseInt(String key) throws IllegalArgumentException {
return Integer.parseInt(key);
}
protected long _parseLong(String key) throws IllegalArgumentException {
return Long.parseLong(key);
}
protected double _parseDouble(String key) throws IllegalArgumentException {
return NumberInput.parseDouble(key);
}
/*
/**********************************************************
/* First: the standard "String as String" deserializer
/**********************************************************
*/
@JacksonStdImpl
final static class StringKD extends StdKeyDeserializer
{
private static final long serialVersionUID = 1L;
private final static StringKD sString = new StringKD(String.class);
private final static StringKD sObject = new StringKD(Object.class);
private StringKD(Class<?> nominalType) { super(-1, nominalType); }
public static StringKD forType(Class<?> nominalType)
{
if (nominalType == String.class) {
return sString;
}
if (nominalType == Object.class) {
return sObject;
}
return new StringKD(nominalType);
}
@Override
public Object deserializeKey(String key, DeserializationContext ctxt) throws IOException, JsonProcessingException {
return key;
}
}
/*
/**********************************************************
/* Key deserializer implementations; other
/**********************************************************
*/
/**
* Key deserializer that wraps a "regular" deserializer (but one
* that must recognize FIELD_NAMEs as text!) to reuse existing
* handlers as key handlers.
*/
final static class DelegatingKD
extends KeyDeserializer // note: NOT the std one
implements java.io.Serializable
{
private static final long serialVersionUID = 1L;
final protected Class<?> _keyClass;
protected final JsonDeserializer<?> _delegate;
protected DelegatingKD(Class<?> cls, JsonDeserializer<?> deser) {
_keyClass = cls;
_delegate = deser;
}
@SuppressWarnings("resource")
@Override
public final Object deserializeKey(String key, DeserializationContext ctxt)
throws IOException
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
/**
* Intermediate base deserializer class that adds more shared accessor
* so that other classes can access information about contained (value) types
*/
@SuppressWarnings("serial")
public abstract class ContainerDeserializerBase<T>
extends StdDeserializer<T>
{
protected ContainerDeserializerBase(JavaType selfType) {
super(selfType);
}
/*
/**********************************************************
/* Overrides
/**********************************************************
*/
@Override
public SettableBeanProperty findBackReference(String refName) {
JsonDeserializer<Object> valueDeser = getContentDeserializer();
if (valueDeser == null) {
throw new IllegalArgumentException("Can not handle managed/back reference '"+refName
+"': type: container deserializer of type "+getClass().getName()+" returned null for 'getContentDeserializer()'");
}
return valueDeser.findBackReference(refName);
}
/*
/**********************************************************
/* Extended API
/**********************************************************
*/
/**
* Accessor for declared type of contained value elements; either exact
* type, or one of its supertypes.
*/
public abstract JavaType getContentType();
/**
* Accesor for deserializer use for deserializing content values.
*/
public abstract JsonDeserializer<Object> getContentDeserializer();
/*
/**********************************************************
/* Shared methods for sub-classes
/**********************************************************
*/
/**
* Helper method called by various Map(-like) deserializers.
*/
protected void wrapAndThrow(Throwable t, Object ref, String key) throws IOException
{
// to handle StackOverflow:
while (t instanceof InvocationTargetException && t.getCause() != null) {
t = t.getCause();
}
// Errors and "plain" IOExceptions to be passed as is
if (t instanceof Error) {
throw (Error) t;
}
// ... except for mapping exceptions
if (t instanceof IOException && !(t instanceof JsonMappingException)) {
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> builders (unlike that of {@link BeanDeserializer}.
*<p>
* Default method implementations are "no-op"s, meaning that methods are implemented
* but have no effect; this is mostly so that new methods can be added in later
* versions.
*/
public abstract class BeanDeserializerModifier
{
/**
* Method called by {@link BeanDeserializerFactory} when it has collected
* initial list of {@link BeanPropertyDefinition}s, and done basic by-name
* and by-type filtering, but before constructing builder or actual
* property handlers; or arranging order.
*
* The most common changes to make at this point are to completely remove
* specified properties, or rename then: other modifications are easier
* to make at later points.
*/
public List<BeanPropertyDefinition> updateProperties(DeserializationConfig config,
BeanDescription beanDesc, List<BeanPropertyDefinition> propDefs) {
return propDefs;
}
/**
* Method called by {@link BeanDeserializerFactory} when it has collected
* basic information such as tentative list of properties to deserialize.
*
* Implementations may choose to modify state of builder (to affect deserializer being
* built), or even completely replace it (if they want to build different kind of
* deserializer). Typically changes mostly concern set of properties to deserialize.
*/
public BeanDeserializerBuilder updateBuilder(DeserializationConfig config,
BeanDescription beanDesc, BeanDeserializerBuilder builder) {
return builder;
}
/**
* Method called by {@link BeanDeserializerFactory} after constructing default
* bean deserializer instance with properties collected and ordered earlier.
* Implementations can modify or replace given deserializer and return deserializer
* to use. Note that although initial deserializer being passed is of type
* {@link BeanDeserializer}, modifiers may return deserializers of other types;
* and this is why implementations must check for type before casting.
*/
public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config,
BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
return deserializer;
}
/*
/**********************************************************
/* Callback methods for other types (since 2.2)
/**********************************************************
*/
/**
* @since 2.2
*/
public JsonDeserializer<?> modifyEnumDeserializer(DeserializationConfig config,
JavaType type, BeanDescription beanDesc, JsonDeserializer
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS><?> deserializer) {
return deserializer;
}
/**
* @since 2.7
*/
public JsonDeserializer<?> modifyReferenceDeserializer(DeserializationConfig config,
ReferenceType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
return deserializer;
}
/**
* Method called by {@link DeserializerFactory} after it has constructed the
* standard deserializer for given
* {@link ArrayType}
* to make it possible to either replace or augment this deserializer with
* additional functionality.
*
* @param config Configuration in use
* @param valueType Type of the value deserializer is used for.
* @param beanDesc Description f
* @param deserializer Default deserializer that would be used.
*
* @return Deserializer to use; either <code>deserializer</code> that was passed
* in, or an instance method constructed.
*
* @since 2.2
*/
public JsonDeserializer<?> modifyArrayDeserializer(DeserializationConfig config,
ArrayType valueType, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
return deserializer;
}
/**
* @since 2.2
*/
public JsonDeserializer<?> modifyCollectionDeserializer(DeserializationConfig config,
CollectionType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
return deserializer;
}
/**
* @since 2.2
*/
public JsonDeserializer<?> modifyCollectionLikeDeserializer(DeserializationConfig config,
CollectionLikeType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
return deserializer;
}
/**
* @since 2.2
*/
public JsonDeserializer<?> modifyMapDeserializer(DeserializationConfig config,
MapType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
return deserializer;
}
/**
* @since 2.2
*/
public JsonDeserializer<?> modifyMapLikeDeserializer(DeserializationConfig config,
MapLikeType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
return deserializer;
}
/**
* Method called by {@link DeserializerFactory} after it has constructed the
* standard key deserializer for given key type.
* This make it possible to replace the default key deserializer, or augment
* it somehow (including optional use of default deserializer with occasional
* override
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.deser.UnresolvedForwardReference;
import com.fasterxml.jackson.databind.deser.ValueInstantiator;
import com.fasterxml.jackson.databind.deser.impl.ReadableObjectId.Referring;
import com.fasterxml.jackson.databind.deser.std.ContainerDeserializerBase;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
/**
* Basic serializer that can take JSON "Array" structure and
* construct a {@link java.util.Collection} instance, with typed contents.
*<p>
* Note: for untyped content (one indicated by passing Object.class
* as the type), {@link UntypedObjectDeserializer} is used instead.
* It can also construct {@link java.util.List}s, but not with specific
* POJO types, only other containers and primitives/wrappers.
*/
@JacksonStdImpl
public class CollectionDeserializer
extends ContainerDeserializerBase<Collection<Object>>
implements ContextualDeserializer
{
private static final long serialVersionUID = -1L; // since 2.5
// // Configuration
protected final JavaType _collectionType;
/**
* Value deserializer.
*/
protected final JsonDeserializer<Object> _valueDeserializer;
/**
* If element instances have polymorphic type information, this
* is the type deserializer that can handle it
*/
protected final TypeDeserializer _valueTypeDeserializer;
// // Instance construction settings:
protected final ValueInstantiator _valueInstantiator;
/**
* Deserializer that is used iff delegate-based creator is
* to be used for deserializing from JSON Object.
*/
protected final JsonDeserializer<Object> _delegateDeserializer;
/**
* Specific override for this instance (from proper, or global per-type overrides)
* to indicate whether single value may be taken to mean an unwrapped one-element array
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> * or not. If null, left to global defaults.
*
* @since 2.7
*/
protected final Boolean _unwrapSingle;
// NOTE: no PropertyBasedCreator, as JSON Arrays have no properties
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
/**
* Constructor for context-free instances, where we do not yet know
* which property is using this deserializer.
*/
public CollectionDeserializer(JavaType collectionType,
JsonDeserializer<Object> valueDeser,
TypeDeserializer valueTypeDeser, ValueInstantiator valueInstantiator)
{
this(collectionType, valueDeser, valueTypeDeser, valueInstantiator, null, null);
}
/**
* Constructor used when creating contextualized instances.
*/
protected CollectionDeserializer(JavaType collectionType,
JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser,
ValueInstantiator valueInstantiator,
JsonDeserializer<Object> delegateDeser,
Boolean unwrapSingle)
{
super(collectionType);
_collectionType = collectionType;
_valueDeserializer = valueDeser;
_valueTypeDeserializer = valueTypeDeser;
_valueInstantiator = valueInstantiator;
_delegateDeserializer = delegateDeser;
_unwrapSingle = unwrapSingle;
}
/**
* Copy-constructor that can be used by sub-classes to allow
* copy-on-write styling copying of settings of an existing instance.
*/
protected CollectionDeserializer(CollectionDeserializer src)
{
super(src._collectionType);
_collectionType = src._collectionType;
_valueDeserializer = src._valueDeserializer;
_valueTypeDeserializer = src._valueTypeDeserializer;
_valueInstantiator = src._valueInstantiator;
_delegateDeserializer = src._delegateDeserializer;
_unwrapSingle = src._unwrapSingle;
}
/**
* Fluent-factory method call to construct contextual instance.
*
* @since 2.7
*/
@SuppressWarnings("unchecked")
protected CollectionDeserializer withResolved(JsonDeserializer<?> dd,
JsonDeserializer<?> vd, TypeDeserializer vtd,
Boolean unwrapSingle)
{
if ((dd == _delegateDeserializer) && (vd == _valueDeserializer) && (vtd == _valueTypeDeserializer)
&& (_unwrapSingle == unwrapSingle)) {
return this;
}
return
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> new CollectionDeserializer(_collectionType,
(JsonDeserializer<Object>) vd, vtd,
_valueInstantiator, (JsonDeserializer<Object>) dd, unwrapSingle);
}
/**
* @deprecated Since 2.7 as it does not pass `unwrapSingle`
*/
@Deprecated // since 2.7 -- will not retain "unwrapSingle" setting
protected CollectionDeserializer withResolved(JsonDeserializer<?> dd,
JsonDeserializer<?> vd, TypeDeserializer vtd)
{
return withResolved(dd, vd, vtd, _unwrapSingle);
}
// Important: do NOT cache if polymorphic values
@Override // since 2.5
public boolean isCachable() {
// 26-Mar-2015, tatu: As per [databind#735], need to be careful
return (_valueDeserializer == null)
&& (_valueTypeDeserializer == null)
&& (_delegateDeserializer == null)
;
}
/*
/**********************************************************
/* Validation, post-processing (ResolvableDeserializer)
/**********************************************************
*/
/**
* Method called to finalize setup of this deserializer,
* when it is known for which property deserializer is needed
* for.
*/
@Override
public CollectionDeserializer createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
// May need to resolve types for delegate-based creators:
JsonDeserializer<Object> delegateDeser = null;
if (_valueInstantiator != null) {
if (_valueInstantiator.canCreateUsingDelegate()) {
JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig());
if (delegateType == null) {
throw new IllegalArgumentException("Invalid delegate-creator definition for "+_collectionType
+": value instantiator ("+_valueInstantiator.getClass().getName()
+") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'");
}
delegateDeser = findDeserializer(ctxt, delegateType, property);
} else if (_valueInstantiator.canCreateUsingArrayDelegate()) {
JavaType delegateType = _valueInstantiator.getArrayDelegateType(ctxt.getConfig());
if (delegateType == null) {
throw new IllegalArgumentException("Invalid array-delegate-creator definition for "+_collectionType
+": value instantiator ("+_
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>valueInstantiator.getClass().getName()
+") returned true for 'canCreateUsingArrayDelegate()', but null for 'getArrayDelegateType()'");
}
delegateDeser = findDeserializer(ctxt, delegateType, property);
}
}
// [databind#1043]: allow per-property allow-wrapping of single overrides:
// 11-Dec-2015, tatu: Should we pass basic `Collection.class`, or more refined? Mostly
// comes down to "List vs Collection" I suppose... for now, pass Collection
Boolean unwrapSingle = findFormatFeature(ctxt, property, Collection.class,
JsonFormat.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
// also, often value deserializer is resolved here:
JsonDeserializer<?> valueDeser = _valueDeserializer;
// May have a content converter
valueDeser = findConvertingContentDeserializer(ctxt, property, valueDeser);
final JavaType vt = _collectionType.getContentType();
if (valueDeser == null) {
valueDeser = ctxt.findContextualValueDeserializer(vt, property);
} else { // if directly assigned, probably not yet contextual, so:
valueDeser = ctxt.handleSecondaryContextualization(valueDeser, property, vt);
}
// and finally, type deserializer needs context as well
TypeDeserializer valueTypeDeser = _valueTypeDeserializer;
if (valueTypeDeser != null) {
valueTypeDeser = valueTypeDeser.forProperty(property);
}
return withResolved(delegateDeser, valueDeser, valueTypeDeser, unwrapSingle);
}
/*
/**********************************************************
/* ContainerDeserializerBase API
/**********************************************************
*/
@Override
public JavaType getContentType() {
return _collectionType.getContentType();
}
@Override
public JsonDeserializer<Object> getContentDeserializer() {
return _valueDeserializer;
}
/*
/**********************************************************
/* JsonDeserializer API
/**********************************************************
*/
@SuppressWarnings("unchecked")
@Override
public Collection<Object> deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException
{
if (_delegateDeserializer != null) {
return (Collection<Object>) _valueInstantiator.createUsingDelegate(ctxt,
_delegateDeserializer.deserialize(p, ctxt
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>));
}
/* Empty String may be ok; bit tricky to check, however, since
* there is also possibility of "auto-wrapping" of single-element arrays.
* Hence we only accept empty String here.
*/
if (p.hasToken(JsonToken.VALUE_STRING)) {
String str = p.getText();
if (str.length() == 0) {
return (Collection<Object>) _valueInstantiator.createFromString(ctxt, str);
}
}
return deserialize(p, ctxt, (Collection<Object>) _valueInstantiator.createUsingDefault(ctxt));
}
@Override
public Collection<Object> deserialize(JsonParser p, DeserializationContext ctxt,
Collection<Object> result)
throws IOException
{
// Ok: must point to START_ARRAY (or equivalent)
if (!p.isExpectedStartArrayToken()) {
return handleNonArray(p, ctxt, result);
}
// [databind#631]: Assign current value, to be accessible by custom serializers
p.setCurrentValue(result);
JsonDeserializer<Object> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
CollectionReferringAccumulator referringAccumulator =
(valueDes.getObjectIdReader() == null) ? null :
new CollectionReferringAccumulator(_collectionType.getContentType().getRawClass(), result);
JsonToken t;
while ((t = p.nextToken()) != JsonToken.END_ARRAY) {
try {
Object value;
if (t == JsonToken.VALUE_NULL) {
value = valueDes.getNullValue(ctxt);
} else if (typeDeser == null) {
value = valueDes.deserialize(p, ctxt);
} else {
value = valueDes.deserializeWithType(p, ctxt, typeDeser);
}
if (referringAccumulator != null) {
referringAccumulator.add(value);
} else {
result.add(value);
}
} catch (UnresolvedForwardReference reference) {
if (referringAccumulator == null) {
throw JsonMappingException
.from(p, "Unresolved forward reference but no identity info", reference);
}
Referring ref = referringAccumulator.handleUnresolvedReference(reference);
reference.getRoid().appendReferring(ref);
} catch (Exception
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> e) {
boolean wrap = (ctxt == null) || ctxt.isEnabled(DeserializationFeature.WRAP_EXCEPTIONS);
if (!wrap && e instanceof RuntimeException) {
throw (RuntimeException)e;
}
throw JsonMappingException.wrapWithPath(e, result, result.size());
}
}
return result;
}
@Override
public Object deserializeWithType(JsonParser p, DeserializationContext ctxt,
TypeDeserializer typeDeserializer)
throws IOException
{
// In future could check current token... for now this should be enough:
return typeDeserializer.deserializeTypedFromArray(p, ctxt);
}
/**
* Helper method called when current token is no START_ARRAY. Will either
* throw an exception, or try to handle value as if member of implicit
* array, depending on configuration.
*/
@SuppressWarnings("unchecked")
protected final Collection<Object> handleNonArray(JsonParser p, DeserializationContext ctxt,
Collection<Object> result)
throws IOException
{
// Implicit arrays from single values?
boolean canWrap = (_unwrapSingle == Boolean.TRUE) ||
((_unwrapSingle == null) &&
ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY));
if (!canWrap) {
return (Collection<Object>) ctxt.handleUnexpectedToken(_collectionType.getRawClass(), p);
}
JsonDeserializer<Object> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
JsonToken t = p.getCurrentToken();
Object value;
try {
if (t == JsonToken.VALUE_NULL) {
value = valueDes.getNullValue(ctxt);
} else if (typeDeser == null) {
value = valueDes.deserialize(p, ctxt);
} else {
value = valueDes.deserializeWithType(p, ctxt, typeDeser);
}
} catch (Exception e) {
// note: pass Object.class, not Object[].class, as we need element type for error info
throw JsonMappingException.wrapWithPath(e, Object.class, result.size());
}
result.add(value);
return result;
}
public final static class CollectionReferringAccumulator {
private final Class<?> _elementType;
private final Collection<Object> _result;
/**
* A list of {@link
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> if (prop == null) {
continue;
}
if (!found) {
found = key.equals(prop.getName());
if (found) {
// need to leave a hole here
_propsInOrder[_findFromOrdered(prop)] = null;
continue;
}
}
props.add(prop);
}
if (!found) {
throw new NoSuchElementException("No entry '"+propToRm.getName()+"' found, can't remove");
}
init(props);
}
/**
* Convenience method that tries to find property with given name, and
* if it is found, call {@link SettableBeanProperty#deserializeAndSet}
* on it, and return true; or, if not found, return false.
* Note, too, that if deserialization is attempted, possible exceptions
* are wrapped if and as necessary, so caller need not handle those.
*
* @since 2.5
*/
public boolean findDeserializeAndSet(JsonParser p, DeserializationContext ctxt,
Object bean, String key) throws IOException
{
final SettableBeanProperty prop = find(key);
if (prop == null) {
return false;
}
try {
prop.deserializeAndSet(p, ctxt, bean);
} catch (Exception e) {
wrapAndThrow(e, bean, key, ctxt);
}
return true;
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("Properties=[");
int count = 0;
Iterator<SettableBeanProperty> it = iterator();
while (it.hasNext()) {
SettableBeanProperty prop = it.next();
if (count++ > 0) {
sb.append(", ");
}
sb.append(prop.getName());
sb.append('(');
sb.append(prop.getType());
sb.append(')');
}
sb.append(']');
return sb.toString();
}
/*
/**********************************************************
/* Helper methods
/**********************************************************
*/
protected SettableBeanProperty _rename(SettableBeanProperty prop, NameTransformer xf)
{
if (prop == null) {
return prop;
}
String newName = xf.transform(prop.getName());
prop = prop.withSimpleName(newName);
Json
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Deserializer<?> deser = prop.getValueDeserializer();
if (deser != null) {
@SuppressWarnings("unchecked")
JsonDeserializer<Object> newDeser = (JsonDeserializer<Object>)
deser.unwrappingDeserializer(xf);
if (newDeser != deser) {
prop = prop.withValueDeserializer(newDeser);
}
}
return prop;
}
protected void wrapAndThrow(Throwable t, Object bean, String fieldName, DeserializationContext ctxt)
throws IOException
{
// inlined 'throwOrReturnThrowable'
while (t instanceof InvocationTargetException && t.getCause() != null) {
t = t.getCause();
}
// Errors to be passed as is
if (t instanceof Error) {
throw (Error) t;
}
// StackOverflowErrors are tricky ones; need to be careful...
boolean wrap = (ctxt == null) || ctxt.isEnabled(DeserializationFeature.WRAP_EXCEPTIONS);
// Ditto for IOExceptions; except we may want to wrap JSON exceptions
if (t instanceof IOException) {
if (!wrap || !(t instanceof JsonProcessingException)) {
throw (IOException) t;
}
} else if (!wrap) { // allow disabling wrapping for unchecked exceptions
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
}
}
throw JsonMappingException.wrapWithPath(t, bean, fieldName);
}
/**
* Helper method used to find exact location of a property with name
* given exactly, not subject to case changes, within hash area.
* Expectation is that such property SHOULD exist, although no
* exception is thrown.
*
* @since 2.7
*/
private final int _findIndexInHash(String key)
{
final int slot = _hashCode(key);
int ix = (slot<<1);
// primary match?
if (key.equals(_hashArea[ix])) {
return ix+1;
}
// no? secondary?
int hashSize = _hashMask+1;
ix = hashSize + (slot>>1) << 1;
if (key.equals(_hashArea[ix])) {
return ix+1;
}
// perhaps spill then
int i = (hashSize + (hashSize>>1)) << 1;
for (int end
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> ctxt.getConfig();
final AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
PropertyMetadata metadata;
{
if (intr == null) {
metadata = PropertyMetadata.STD_REQUIRED_OR_OPTIONAL;
} else {
Boolean b = intr.hasRequiredMarker(param);
boolean req = (b != null && b.booleanValue());
String desc = intr.findPropertyDescription(param);
Integer idx = intr.findPropertyIndex(param);
String def = intr.findPropertyDefaultValue(param);
metadata = PropertyMetadata.construct(req, desc, idx, def);
}
}
JavaType type = resolveMemberAndTypeAnnotations(ctxt, param, param.getType());
BeanProperty.Std property = new BeanProperty.Std(name, type,
intr.findWrapperName(param),
beanDesc.getClassAnnotations(), param, metadata);
// Type deserializer: either comes from property (and already resolved)
TypeDeserializer typeDeser = (TypeDeserializer) type.getTypeHandler();
// or if not, based on type being referenced:
if (typeDeser == null) {
typeDeser = findTypeDeserializer(config, type);
}
// Note: contextualization of typeDeser _should_ occur in constructor of CreatorProperty
// so it is not called directly here
SettableBeanProperty prop = new CreatorProperty(name, type, property.getWrapperName(),
typeDeser, beanDesc.getClassAnnotations(), param, index, injectableValueId,
metadata);
JsonDeserializer<?> deser = findDeserializerFromAnnotation(ctxt, param);
if (deser == null) {
deser = type.getValueHandler();
}
if (deser != null) {
// As per [databind#462] need to ensure we contextualize deserializer before passing it on
deser = ctxt.handlePrimaryContextualization(deser, prop, type);
prop = prop.withValueDeserializer(deser);
}
return prop;
}
protected PropertyName _findParamName(AnnotatedParameter param, AnnotationIntrospector intr)
{
if (param != null && intr != null) {
PropertyName name = intr.findNameForDeserialization(param);
if (name != null) {
return name;
}
// 14-Apr-2014,
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> tatu: Need to also consider possible implicit name
// (for JDK8, or via paranamer)
String str = intr.findImplicitPropertyName(param);
if (str != null && !str.isEmpty()) {
return PropertyName.construct(str);
}
}
return null;
}
protected PropertyName _findImplicitParamName(AnnotatedParameter param, AnnotationIntrospector intr)
{
String str = intr.findImplicitPropertyName(param);
if (str != null && !str.isEmpty()) {
return PropertyName.construct(str);
}
return null;
}
@Deprecated // in 2.6, remove from 2.7
protected PropertyName _findExplicitParamName(AnnotatedParameter param, AnnotationIntrospector intr)
{
if (param != null && intr != null) {
return intr.findNameForDeserialization(param);
}
return null;
}
@Deprecated // in 2.6, remove from 2.7
protected boolean _hasExplicitParamName(AnnotatedParameter param, AnnotationIntrospector intr)
{
if (param != null && intr != null) {
PropertyName n = intr.findNameForDeserialization(param);
return (n != null) && n.hasSimpleName();
}
return false;
}
/*
/**********************************************************
/* JsonDeserializerFactory impl: array deserializers
/**********************************************************
*/
@Override
public JsonDeserializer<?> createArrayDeserializer(DeserializationContext ctxt,
ArrayType type, final BeanDescription beanDesc)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
JavaType elemType = type.getContentType();
// Very first thing: is deserializer hard-coded for elements?
JsonDeserializer<Object> contentDeser = elemType.getValueHandler();
// Then optional type info: if type has been resolved, we may already know type deserializer:
TypeDeserializer elemTypeDeser = elemType.getTypeHandler();
// but if not, may still be possible to find:
if (elemTypeDeser == null) {
elemTypeDeser = findTypeDeserializer(config, elemType);
}
// 23-Nov-2010, tatu: Custom array deserializer?
JsonDeserializer<?> deser = _findCustomArrayDeserializer(type,
config, beanDesc
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>, elemTypeDeser, contentDeser);
if (deser == null) {
if (contentDeser == null) {
Class<?> raw = elemType.getRawClass();
if (elemType.isPrimitive()) {
return PrimitiveArrayDeserializers.forType(raw);
} else if (raw == String.class) {
return StringArrayDeserializer.instance;
}
}
deser = new ObjectArrayDeserializer(type, contentDeser, elemTypeDeser);
}
// and then new with 2.2: ability to post-process it too (Issue#120)
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deser = mod.modifyArrayDeserializer(config, type, beanDesc, deser);
}
}
return deser;
}
/*
/**********************************************************
/* JsonDeserializerFactory impl: Collection(-like) deserializers
/**********************************************************
*/
@Override
public JsonDeserializer<?> createCollectionDeserializer(DeserializationContext ctxt,
CollectionType type, BeanDescription beanDesc)
throws JsonMappingException
{
JavaType contentType = type.getContentType();
// Very first thing: is deserializer hard-coded for elements?
JsonDeserializer<Object> contentDeser = contentType.getValueHandler();
final DeserializationConfig config = ctxt.getConfig();
// Then optional type info: if type has been resolved, we may already know type deserializer:
TypeDeserializer contentTypeDeser = contentType.getTypeHandler();
// but if not, may still be possible to find:
if (contentTypeDeser == null) {
contentTypeDeser = findTypeDeserializer(config, contentType);
}
// 23-Nov-2010, tatu: Custom deserializer?
JsonDeserializer<?> deser = _findCustomCollectionDeserializer(type,
config, beanDesc, contentTypeDeser, contentDeser);
if (deser == null) {
Class<?> collectionClass = type.getRawClass();
if (contentDeser == null) { // not defined by annotation
// One special type: EnumSet:
if (EnumSet.class.isAssignableFrom(collectionClass)) {
deser = new EnumSetDeserializer(contentType, null);
}
}
}
/* One twist: if we are being asked to instantiate an interface or
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> * abstract Collection, we need to either find something that implements
* the thing, or give up.
*
* Note that we do NOT try to guess based on secondary interfaces
* here; that would probably not work correctly since casts would
* fail later on (as the primary type is not the interface we'd
* be implementing)
*/
if (deser == null) {
if (type.isInterface() || type.isAbstract()) {
CollectionType implType = _mapAbstractCollectionType(type, config);
if (implType == null) {
// [databind#292]: Actually, may be fine, but only if polymorphich deser enabled
if (type.getTypeHandler() == null) {
throw new IllegalArgumentException("Can not find a deserializer for non-concrete Collection type "+type);
}
deser = AbstractDeserializer.constructForNonPOJO(beanDesc);
} else {
type = implType;
// But if so, also need to re-check creators...
beanDesc = config.introspectForCreation(type);
}
}
if (deser == null) {
ValueInstantiator inst = findValueInstantiator(ctxt, beanDesc);
if (!inst.canCreateUsingDefault()) {
// [databind#161]: No default constructor for ArrayBlockingQueue...
if (type.getRawClass() == ArrayBlockingQueue.class) {
return new ArrayBlockingQueueDeserializer(type, contentDeser, contentTypeDeser, inst);
}
}
// Can use more optimal deserializer if content type is String, so:
if (contentType.getRawClass() == String.class) {
// no value type deserializer because Strings are one of natural/native types:
deser = new StringCollectionDeserializer(type, contentDeser, inst);
} else {
deser = new CollectionDeserializer(type, contentDeser, contentTypeDeser, inst);
}
}
}
// allow post-processing it too
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deser = mod.modifyCollectionDeserializer(config, type, beanDesc, deser);
}
}
return deser;
}
protected CollectionType _mapAbstractCollectionType(JavaType type, DeserializationConfig config)
{
Class<?> collection
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Class = type.getRawClass();
collectionClass = _collectionFallbacks.get(collectionClass.getName());
if (collectionClass == null) {
return null;
}
return (CollectionType) config.constructSpecializedType(type, collectionClass);
}
// Copied almost verbatim from "createCollectionDeserializer" -- should try to share more code
@Override
public JsonDeserializer<?> createCollectionLikeDeserializer(DeserializationContext ctxt,
CollectionLikeType type, final BeanDescription beanDesc)
throws JsonMappingException
{
JavaType contentType = type.getContentType();
// Very first thing: is deserializer hard-coded for elements?
JsonDeserializer<Object> contentDeser = contentType.getValueHandler();
final DeserializationConfig config = ctxt.getConfig();
// Then optional type info (1.5): if type has been resolved, we may already know type deserializer:
TypeDeserializer contentTypeDeser = contentType.getTypeHandler();
// but if not, may still be possible to find:
if (contentTypeDeser == null) {
contentTypeDeser = findTypeDeserializer(config, contentType);
}
JsonDeserializer<?> deser = _findCustomCollectionLikeDeserializer(type, config, beanDesc,
contentTypeDeser, contentDeser);
if (deser != null) {
// and then new with 2.2: ability to post-process it too (Issue#120)
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deser = mod.modifyCollectionLikeDeserializer(config, type, beanDesc, deser);
}
}
}
return deser;
}
/*
/**********************************************************
/* JsonDeserializerFactory impl: Map(-like) deserializers
/**********************************************************
*/
@Override
public JsonDeserializer<?> createMapDeserializer(DeserializationContext ctxt,
MapType type, BeanDescription beanDesc)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
JavaType keyType = type.getKeyType();
JavaType contentType = type.getContentType();
// First: is there annotation-specified deserializer for values?
@SuppressWarnings("unchecked")
JsonDeserializer<Object> contentDeser = (JsonDeserializer<Object>) contentType.getValueHandler();
// Ok: need a key deserializer (null indicates 'default' here
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>)
KeyDeserializer keyDes = (KeyDeserializer) keyType.getValueHandler();
// Then optional type info; either attached to type, or resolved separately:
TypeDeserializer contentTypeDeser = contentType.getTypeHandler();
// but if not, may still be possible to find:
if (contentTypeDeser == null) {
contentTypeDeser = findTypeDeserializer(config, contentType);
}
// 23-Nov-2010, tatu: Custom deserializer?
JsonDeserializer<?> deser = _findCustomMapDeserializer(type, config, beanDesc,
keyDes, contentTypeDeser, contentDeser);
if (deser == null) {
// Value handling is identical for all, but EnumMap requires special handling for keys
Class<?> mapClass = type.getRawClass();
if (EnumMap.class.isAssignableFrom(mapClass)) {
Class<?> kt = keyType.getRawClass();
if (kt == null || !kt.isEnum()) {
throw new IllegalArgumentException("Can not construct EnumMap; generic (key) type not available");
}
deser = new EnumMapDeserializer(type, null, contentDeser, contentTypeDeser);
}
// Otherwise, generic handler works ok.
/* But there is one more twist: if we are being asked to instantiate
* an interface or abstract Map, we need to either find something
* that implements the thing, or give up.
*
* Note that we do NOT try to guess based on secondary interfaces
* here; that would probably not work correctly since casts would
* fail later on (as the primary type is not the interface we'd
* be implementing)
*/
if (deser == null) {
if (type.isInterface() || type.isAbstract()) {
@SuppressWarnings("rawtypes")
Class<? extends Map> fallback = _mapFallbacks.get(mapClass.getName());
if (fallback != null) {
mapClass = fallback;
type = (MapType) config.constructSpecializedType(type, mapClass);
// But if so, also need to re-check creators...
beanDesc = config.introspectForCreation(type);
} else {
// [databind#292]: Actually, may be fine, but only if polymorphic deser enabled
if (type.getTypeHandler() == null) {
throw
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> new IllegalArgumentException("Can not find a deserializer for non-concrete Map type "+type);
}
deser = AbstractDeserializer.constructForNonPOJO(beanDesc);
}
}
if (deser == null) {
ValueInstantiator inst = findValueInstantiator(ctxt, beanDesc);
// 01-May-2016, tatu: Which base type to use here gets tricky, since
// most often it ought to be `Map` or `EnumMap`, but due to abstract
// mapping it will more likely be concrete type like `HashMap`.
// So, for time being, just pass `Map.class`
MapDeserializer md = new MapDeserializer(type, inst, keyDes, contentDeser, contentTypeDeser);
JsonIgnoreProperties.Value ignorals = config.getDefaultPropertyIgnorals(Map.class,
beanDesc.getClassInfo());
Set<String> ignored = (ignorals == null) ? null
: ignorals.findIgnoredForDeserialization();
md.setIgnorableProperties(ignored);
deser = md;
}
}
}
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deser = mod.modifyMapDeserializer(config, type, beanDesc, deser);
}
}
return deser;
}
// Copied almost verbatim from "createMapDeserializer" -- should try to share more code
@Override
public JsonDeserializer<?> createMapLikeDeserializer(DeserializationContext ctxt,
MapLikeType type, final BeanDescription beanDesc)
throws JsonMappingException
{
JavaType keyType = type.getKeyType();
JavaType contentType = type.getContentType();
final DeserializationConfig config = ctxt.getConfig();
// First: is there annotation-specified deserializer for values?
@SuppressWarnings("unchecked")
JsonDeserializer<Object> contentDeser = (JsonDeserializer<Object>) contentType.getValueHandler();
// Ok: need a key deserializer (null indicates 'default' here)
KeyDeserializer keyDes = (KeyDeserializer) keyType.getValueHandler();
/* !!! 24-Jan-2012, tatu: NOTE: impls MUST use resolve() to find key deserializer!
if (keyDes == null) {
keyDes = p.find
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>KeyDeserializer(config, keyType, property);
}
*/
// Then optional type info (1.5); either attached to type, or resolve separately:
TypeDeserializer contentTypeDeser = contentType.getTypeHandler();
// but if not, may still be possible to find:
if (contentTypeDeser == null) {
contentTypeDeser = findTypeDeserializer(config, contentType);
}
JsonDeserializer<?> deser = _findCustomMapLikeDeserializer(type, config,
beanDesc, keyDes, contentTypeDeser, contentDeser);
if (deser != null) {
// and then new with 2.2: ability to post-process it too (Issue#120)
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deser = mod.modifyMapLikeDeserializer(config, type, beanDesc, deser);
}
}
}
return deser;
}
/*
/**********************************************************
/* JsonDeserializerFactory impl: other types
/**********************************************************
*/
/**
* Factory method for constructing serializers of {@link Enum} types.
*/
@Override
public JsonDeserializer<?> createEnumDeserializer(DeserializationContext ctxt,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
final Class<?> enumClass = type.getRawClass();
// 23-Nov-2010, tatu: Custom deserializer?
JsonDeserializer<?> deser = _findCustomEnumDeserializer(enumClass, config, beanDesc);
if (deser == null) {
ValueInstantiator valueInstantiator = _constructDefaultValueInstantiator(ctxt, beanDesc);
SettableBeanProperty[] creatorProps = (valueInstantiator == null) ? null
: valueInstantiator.getFromObjectArguments(ctxt.getConfig());
// May have @JsonCreator for static factory method:
for (AnnotatedMethod factory : beanDesc.getFactoryMethods()) {
if (ctxt.getAnnotationIntrospector().hasCreatorAnnotation(factory)) {
if (factory.getParameterCount() == 0) { // [databind#960]
deser = EnumDeserializer.deserializerForNoArgsCreator(config, enumClass, factory);
break;
}
Class<?> returnType = factory.getRawReturnType();
// usually should
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> be class, but may be just plain Enum<?> (for Enum.valueOf()?)
if (returnType.isAssignableFrom(enumClass)) {
deser = EnumDeserializer.deserializerForCreator(config, enumClass, factory, valueInstantiator, creatorProps);
break;
}
}
}
// Need to consider @JsonValue if one found
if (deser == null) {
deser = new EnumDeserializer(constructEnumResolver(enumClass,
config, beanDesc.findJsonValueMethod()));
}
}
// and then post-process it too
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deser = mod.modifyEnumDeserializer(config, type, beanDesc, deser);
}
}
return deser;
}
@Override
public JsonDeserializer<?> createTreeDeserializer(DeserializationConfig config,
JavaType nodeType, BeanDescription beanDesc)
throws JsonMappingException
{
@SuppressWarnings("unchecked")
Class<? extends JsonNode> nodeClass = (Class<? extends JsonNode>) nodeType.getRawClass();
// 23-Nov-2010, tatu: Custom deserializer?
JsonDeserializer<?> custom = _findCustomTreeNodeDeserializer(nodeClass, config,
beanDesc);
if (custom != null) {
return custom;
}
return JsonNodeDeserializer.getDeserializer(nodeClass);
}
@Override
public JsonDeserializer<?> createReferenceDeserializer(DeserializationContext ctxt,
ReferenceType type, BeanDescription beanDesc)
throws JsonMappingException
{
JavaType contentType = type.getContentType();
// Very first thing: is deserializer hard-coded for elements?
JsonDeserializer<Object> contentDeser = contentType.getValueHandler();
final DeserializationConfig config = ctxt.getConfig();
// Then optional type info: if type has been resolved, we may already know type deserializer:
TypeDeserializer contentTypeDeser = contentType.getTypeHandler();
if (contentTypeDeser == null) { // or if not, may be able to find:
contentTypeDeser = findTypeDeserializer(config, contentType);
}
JsonDeserializer<?> deser = _findCustomReferenceDeserializer(type, config, beanDesc,
contentTypeDeser, contentDeser);
if (deser == null) {
// Just one referential type as of JDK 1.7 / Java
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> 7: AtomicReference (Java 8 adds Optional)
if (AtomicReference.class.isAssignableFrom(type.getRawClass())) {
return new AtomicReferenceDeserializer(type, contentTypeDeser, contentDeser);
}
}
if (deser != null) {
// and then post-process
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deser = mod.modifyReferenceDeserializer(config, type, beanDesc, deser);
}
}
}
return deser;
}
/*
/**********************************************************
/* JsonDeserializerFactory impl (partial): type deserializers
/**********************************************************
*/
@Override
public TypeDeserializer findTypeDeserializer(DeserializationConfig config,
JavaType baseType)
throws JsonMappingException
{
BeanDescription bean = config.introspectClassAnnotations(baseType.getRawClass());
AnnotatedClass ac = bean.getClassInfo();
AnnotationIntrospector ai = config.getAnnotationIntrospector();
TypeResolverBuilder<?> b = ai.findTypeResolver(config, ac, baseType);
/* Ok: if there is no explicit type info handler, we may want to
* use a default. If so, config object knows what to use.
*/
Collection<NamedType> subtypes = null;
if (b == null) {
b = config.getDefaultTyper(baseType);
if (b == null) {
return null;
}
} else {
subtypes = config.getSubtypeResolver().collectAndResolveSubtypesByTypeId(config, ac);
}
// May need to figure out default implementation, if none found yet
// (note: check for abstract type is not 100% mandatory, more of an optimization)
if ((b.getDefaultImpl() == null) && baseType.isAbstract()) {
JavaType defaultType = mapAbstractType(config, baseType);
if (defaultType != null && defaultType.getRawClass() != baseType.getRawClass()) {
b = b.defaultImpl(defaultType.getRawClass());
}
}
return b.buildTypeDeserializer(config, baseType, subtypes);
}
/**
* Overridable method called after checking all other types.
*
* @since 2.2
*/
protected JsonDeserializer<?> findOptional
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>StdDeserializer(DeserializationContext ctxt,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException
{
return OptionalHandlerFactory.instance.findDeserializer(type, ctxt.getConfig(), beanDesc);
}
/*
/**********************************************************
/* JsonDeserializerFactory impl (partial): key deserializers
/**********************************************************
*/
@Override
public KeyDeserializer createKeyDeserializer(DeserializationContext ctxt,
JavaType type)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
KeyDeserializer deser = null;
if (_factoryConfig.hasKeyDeserializers()) {
BeanDescription beanDesc = config.introspectClassAnnotations(type.getRawClass());
for (KeyDeserializers d : _factoryConfig.keyDeserializers()) {
deser = d.findKeyDeserializer(type, config, beanDesc);
if (deser != null) {
break;
}
}
}
// the only non-standard thing is this:
if (deser == null) {
if (type.isEnumType()) {
deser = _createEnumKeyDeserializer(ctxt, type);
} else {
deser = StdKeyDeserializers.findStringBasedKeyDeserializer(config, type);
}
}
// and then post-processing
if (deser != null) {
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deser = mod.modifyKeyDeserializer(config, type, deser);
}
}
}
return deser;
}
private KeyDeserializer _createEnumKeyDeserializer(DeserializationContext ctxt,
JavaType type)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
Class<?> enumClass = type.getRawClass();
BeanDescription beanDesc = config.introspect(type);
// 24-Sep-2015, bim: a key deserializer is the preferred thing.
KeyDeserializer des = findKeyDeserializerFromAnnotation(ctxt, beanDesc.getClassInfo());
if (des != null) {
return des;
} else {
// 24-Sep-2015, bim: if no key deser, look for enum deserializer first, then a plain deser.
JsonDeserializer<?> custom = _findCustomEnumDeserializer(enumClass, config, bean
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Desc);
if (custom != null) {
return StdKeyDeserializers.constructDelegatingKeyDeserializer(config, type, custom);
}
JsonDeserializer<?> valueDesForKey = findDeserializerFromAnnotation(ctxt, beanDesc.getClassInfo());
if (valueDesForKey != null) {
return StdKeyDeserializers.constructDelegatingKeyDeserializer(config, type, valueDesForKey);
}
}
EnumResolver enumRes = constructEnumResolver(enumClass, config, beanDesc.findJsonValueMethod());
// May have @JsonCreator for static factory method:
final AnnotationIntrospector ai = config.getAnnotationIntrospector();
for (AnnotatedMethod factory : beanDesc.getFactoryMethods()) {
if (ai.hasCreatorAnnotation(factory)) {
int argCount = factory.getParameterCount();
if (argCount == 1) {
Class<?> returnType = factory.getRawReturnType();
// usually should be class, but may be just plain Enum<?> (for Enum.valueOf()?)
if (returnType.isAssignableFrom(enumClass)) {
// note: mostly copied from 'EnumDeserializer.deserializerForCreator(...)'
if (factory.getRawParameterType(0) != String.class) {
throw new IllegalArgumentException("Parameter #0 type for factory method ("+factory+") not suitable, must be java.lang.String");
}
if (config.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(factory.getMember(),
ctxt.isEnabled(MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS));
}
return StdKeyDeserializers.constructEnumKeyDeserializer(enumRes, factory);
}
}
throw new IllegalArgumentException("Unsuitable method ("+factory+") decorated with @JsonCreator (for Enum type "
+enumClass.getName()+")");
}
}
// Also, need to consider @JsonValue, if one found
return StdKeyDeserializers.constructEnumKeyDeserializer(enumRes);
}
/*
/**********************************************************
/* Extended API
/**********************************************************
*/
/**
* Method called to create a type information deserializer for values of
* given non-container property, if one is needed.
* If not needed (no polymorphic handling configured for property), should return null.
*<p>
* Note that this method is only called for non-container bean properties,
* and not for values in
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> propertyEntity, contentType);
return b.buildTypeDeserializer(config, contentType, subtypes);
}
/**
* Helper method called to find one of default serializers for "well-known"
* platform types: JDK-provided types, and small number of public Jackson
* API types.
*
* @since 2.2
*/
public JsonDeserializer<?> findDefaultDeserializer(DeserializationContext ctxt,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException
{
Class<?> rawType = type.getRawClass();
// Object ("untyped"), String equivalents:
if (rawType == CLASS_OBJECT) {
// 11-Feb-2015, tatu: As per [databind#700] need to be careful wrt non-default Map, List.
DeserializationConfig config = ctxt.getConfig();
JavaType lt, mt;
if (_factoryConfig.hasAbstractTypeResolvers()) {
lt = _findRemappedType(config, List.class);
mt = _findRemappedType(config, Map.class);
} else {
lt = mt = null;
}
return new UntypedObjectDeserializer(lt, mt);
}
if (rawType == CLASS_STRING || rawType == CLASS_CHAR_BUFFER) {
return StringDeserializer.instance;
}
if (rawType == CLASS_ITERABLE) {
// [databind#199]: Can and should 'upgrade' to a Collection type:
TypeFactory tf = ctxt.getTypeFactory();
JavaType[] tps = tf.findTypeParameters(type, CLASS_ITERABLE);
JavaType elemType = (tps == null || tps.length != 1) ? TypeFactory.unknownType() : tps[0];
CollectionType ct = tf.constructCollectionType(Collection.class, elemType);
// Should we re-introspect beanDesc? For now let's not...
return createCollectionDeserializer(ctxt, ct, beanDesc);
}
if (rawType == CLASS_MAP_ENTRY) {
// 28-Apr-2015, tatu: TypeFactory does it all for us already so
JavaType kt = type.containedType(0);
if (kt == null) {
kt = TypeFactory.unknownType();
}
JavaType vt =
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> type.containedType(1);
if (vt == null) {
vt = TypeFactory.unknownType();
}
TypeDeserializer vts = (TypeDeserializer) vt.getTypeHandler();
if (vts == null) {
vts = findTypeDeserializer(ctxt.getConfig(), vt);
}
JsonDeserializer<Object> valueDeser = vt.getValueHandler();
KeyDeserializer keyDes = (KeyDeserializer) kt.getValueHandler();
return new MapEntryDeserializer(type, keyDes, valueDeser, vts);
}
String clsName = rawType.getName();
if (rawType.isPrimitive() || clsName.startsWith("java.")) {
// Primitives/wrappers, other Numbers:
JsonDeserializer<?> deser = NumberDeserializers.find(rawType, clsName);
if (deser == null) {
deser = DateDeserializers.find(rawType, clsName);
}
if (deser != null) {
return deser;
}
}
// and a few Jackson types as well:
if (rawType == TokenBuffer.class) {
return new TokenBufferDeserializer();
}
JsonDeserializer<?> deser = findOptionalStdDeserializer(ctxt, type, beanDesc);
if (deser != null) {
return deser;
}
return JdkDeserializers.find(rawType, clsName);
}
protected JavaType _findRemappedType(DeserializationConfig config, Class<?> rawType) throws JsonMappingException {
JavaType type = mapAbstractType(config, config.constructType(rawType));
return (type == null || type.hasRawClass(rawType)) ? null : type;
}
/*
/**********************************************************
/* Helper methods, finding custom deserializers
/**********************************************************
*/
protected JsonDeserializer<?> _findCustomTreeNodeDeserializer(Class<? extends JsonNode> type,
DeserializationConfig config, BeanDescription beanDesc)
throws JsonMappingException
{
for (Deserializers d : _factoryConfig.deserializers()) {
JsonDeserializer<?> deser = d.findTreeNodeDeserializer(type, config, beanDesc);
if (deser != null) {
return deser;
}
}
return null;
}
protected JsonDeserializer<?> _findCustomReferenceDeserializer(ReferenceType type,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer contentType
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Deserializer, JsonDeserializer<?> contentDeserializer)
throws JsonMappingException
{
for (Deserializers d : _factoryConfig.deserializers()) {
JsonDeserializer<?> deser = d.findReferenceDeserializer(type, config, beanDesc,
contentTypeDeserializer, contentDeserializer);
if (deser != null) {
return deser;
}
}
return null;
}
@SuppressWarnings("unchecked")
protected JsonDeserializer<Object> _findCustomBeanDeserializer(JavaType type,
DeserializationConfig config, BeanDescription beanDesc)
throws JsonMappingException
{
for (Deserializers d : _factoryConfig.deserializers()) {
JsonDeserializer<?> deser = d.findBeanDeserializer(type, config, beanDesc);
if (deser != null) {
return (JsonDeserializer<Object>) deser;
}
}
return null;
}
protected JsonDeserializer<?> _findCustomArrayDeserializer(ArrayType type,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException
{
for (Deserializers d : _factoryConfig.deserializers()) {
JsonDeserializer<?> deser = d.findArrayDeserializer(type, config,
beanDesc, elementTypeDeserializer, elementDeserializer);
if (deser != null) {
return deser;
}
}
return null;
}
protected JsonDeserializer<?> _findCustomCollectionDeserializer(CollectionType type,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException
{
for (Deserializers d : _factoryConfig.deserializers()) {
JsonDeserializer<?> deser = d.findCollectionDeserializer(type, config, beanDesc,
elementTypeDeserializer, elementDeserializer);
if (deser != null) {
return deser;
}
}
return null;
}
protected JsonDeserializer<?> _findCustomCollectionLikeDeserializer(CollectionLikeType type,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException
{
for (Deserializers d : _factoryConfig.deserializers()) {
JsonDeserializer<?> deser = d.findCollectionLikeDeserializer(type, config, beanDesc,
elementTypeDeserializer, elementDeserializer);
if (deser != null) {
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
return deser;
}
}
return null;
}
protected JsonDeserializer<?> _findCustomEnumDeserializer(Class<?> type,
DeserializationConfig config, BeanDescription beanDesc)
throws JsonMappingException
{
for (Deserializers d : _factoryConfig.deserializers()) {
JsonDeserializer<?> deser = d.findEnumDeserializer(type, config, beanDesc);
if (deser != null) {
return deser;
}
}
return null;
}
protected JsonDeserializer<?> _findCustomMapDeserializer(MapType type,
DeserializationConfig config, BeanDescription beanDesc,
KeyDeserializer keyDeserializer,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException
{
for (Deserializers d : _factoryConfig.deserializers()) {
JsonDeserializer<?> deser = d.findMapDeserializer(type, config, beanDesc,
keyDeserializer, elementTypeDeserializer, elementDeserializer);
if (deser != null) {
return deser;
}
}
return null;
}
protected JsonDeserializer<?> _findCustomMapLikeDeserializer(MapLikeType type,
DeserializationConfig config, BeanDescription beanDesc,
KeyDeserializer keyDeserializer,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException
{
for (Deserializers d : _factoryConfig.deserializers()) {
JsonDeserializer<?> deser = d.findMapLikeDeserializer(type, config, beanDesc,
keyDeserializer, elementTypeDeserializer, elementDeserializer);
if (deser != null) {
return deser;
}
}
return null;
}
/*
/**********************************************************
/* Helper methods, value/content/key type introspection
/**********************************************************
*/
/**
* Helper method called to check if a class or method
* has annotation that tells which class to use for deserialization; and if
* so, to instantiate, that deserializer to use.
* Note that deserializer will NOT yet be contextualized so caller needs to
* take care to call contextualization appropriately.
* Returns null if no such annotation found.
*/
protected JsonDeserializer<Object> findDeserializerFromAnnotation(DeserializationContext ctxt,
Annotated ann)
throws JsonMappingException
{
AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
if (intr != null) {
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> Object deserDef = intr.findDeserializer(ann);
if (deserDef != null) {
return ctxt.deserializerInstance(ann, deserDef);
}
}
return null;
}
/**
* Helper method called to check if a class or method
* has annotation that tells which class to use for deserialization.
* Returns null if no such annotation found.
*/
protected KeyDeserializer findKeyDeserializerFromAnnotation(DeserializationContext ctxt,
Annotated ann)
throws JsonMappingException
{
AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
if (intr != null) {
Object deserDef = intr.findKeyDeserializer(ann);
if (deserDef != null) {
return ctxt.keyDeserializerInstance(ann, deserDef);
}
}
return null;
}
/**
* Helper method used to resolve additional type-related annotation information
* like type overrides, or handler (serializer, deserializer) overrides,
* so that from declared field, property or constructor parameter type
* is used as the base and modified based on annotations, if any.
*
* @since 2.8 Combines functionality of <code>modifyTypeByAnnotation</code>
* and <code>resolveType</code>
*/
protected JavaType resolveMemberAndTypeAnnotations(DeserializationContext ctxt,
AnnotatedMember member, JavaType type)
throws JsonMappingException
{
AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
if (intr == null) {
return type;
}
// First things first: see if we can find annotations on declared
// type
if (type.isMapLikeType()) {
JavaType keyType = type.getKeyType();
if (keyType != null) {
Object kdDef = intr.findKeyDeserializer(member);
KeyDeserializer kd = ctxt.keyDeserializerInstance(member, kdDef);
if (kd != null) {
type = ((MapLikeType) type).withKeyValueHandler(kd);
keyType = type.getKeyType(); // just in case it's used below
}
}
}
if (type.hasContentType()) { // that is, is either container- or reference-type
Object cdDef = intr.findContentDeserializer(member);
JsonDeserializer<?> cd = ctxt.deserializerInstance(member
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> /**
* Convenience method for creating a new factory instance with additional deserializer
* provider.
*/
public abstract DeserializerFactory withAdditionalDeserializers(Deserializers additional);
/**
* Convenience method for creating a new factory instance with additional
* {@link KeyDeserializers}.
*/
public abstract DeserializerFactory withAdditionalKeyDeserializers(KeyDeserializers additional);
/**
* Convenience method for creating a new factory instance with additional
* {@link BeanDeserializerModifier}.
*/
public abstract DeserializerFactory withDeserializerModifier(BeanDeserializerModifier modifier);
/**
* Convenience method for creating a new factory instance with additional
* {@link AbstractTypeResolver}.
*/
public abstract DeserializerFactory withAbstractTypeResolver(AbstractTypeResolver resolver);
/**
* Convenience method for creating a new factory instance with additional
* {@link ValueInstantiators}.
*/
public abstract DeserializerFactory withValueInstantiators(ValueInstantiators instantiators);
/*
/**********************************************************
/* Basic DeserializerFactory API:
/**********************************************************
*/
/**
* Method that can be called to try to resolve an abstract type
* (interface, abstract class) into a concrete type, or at least
* something "more concrete" (abstract class instead of interface).
* Will either return passed type, or a more specific type.
*/
public abstract JavaType mapAbstractType(DeserializationConfig config, JavaType type)
throws JsonMappingException;
/**
* Method that is to find all creators (constructors, factory methods)
* for the bean type to deserialize.
*/
public abstract ValueInstantiator findValueInstantiator(DeserializationContext ctxt,
BeanDescription beanDesc)
throws JsonMappingException;
/**
* Method called to create (or, for completely immutable deserializers,
* reuse) a deserializer that can convert JSON content into values of
* specified Java "bean" (POJO) type.
* At this point it is known that the type is not otherwise recognized
* as one of structured types (array, Collection, Map) or a well-known
* JDK type (enum, primitives/wrappers, String); this method only
* gets called if other options are exhausted. This also means that
* this method can be overridden to add support for custom types.
*
* @param type Type to be deserialized
*/
public abstract JsonDeserializer<Object> createBeanDeserializer(Deserialization
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Context ctxt,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException;
/**
* Method called to create a deserializer that will use specified Builder
* class for building value instances.
*/
public abstract JsonDeserializer<Object> createBuilderBasedDeserializer(
DeserializationContext ctxt, JavaType type, BeanDescription beanDesc,
Class<?> builderClass)
throws JsonMappingException;
public abstract JsonDeserializer<?> createEnumDeserializer(DeserializationContext ctxt,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException;
/**
* @since 2.7
*/
public abstract JsonDeserializer<?> createReferenceDeserializer(DeserializationContext ctxt,
ReferenceType type, BeanDescription beanDesc)
throws JsonMappingException;
/**
* Method called to create and return a deserializer that can construct
* JsonNode(s) from JSON content.
*/
public abstract JsonDeserializer<?> createTreeDeserializer(DeserializationConfig config,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException;
/**
* Method called to create (or, for completely immutable deserializers,
* reuse) a deserializer that can convert JSON content into values of
* specified Java type.
*
* @param type Type to be deserialized
*/
public abstract JsonDeserializer<?> createArrayDeserializer(DeserializationContext ctxt,
ArrayType type, BeanDescription beanDesc)
throws JsonMappingException;
public abstract JsonDeserializer<?> createCollectionDeserializer(DeserializationContext ctxt,
CollectionType type, BeanDescription beanDesc)
throws JsonMappingException;
public abstract JsonDeserializer<?> createCollectionLikeDeserializer(DeserializationContext ctxt,
CollectionLikeType type, BeanDescription beanDesc)
throws JsonMappingException;
public abstract JsonDeserializer<?> createMapDeserializer(DeserializationContext ctxt,
MapType type, BeanDescription beanDesc)
throws JsonMappingException;
public abstract JsonDeserializer<?> createMapLikeDeserializer(DeserializationContext ctxt,
MapLikeType type, BeanDescription beanDesc)
throws JsonMappingException;
/**
* Method called to find if factory knows how to create a key deserializer
* for specified type; currently this means checking if a module has registered
* possible deserializers.
*
* @return Key deserializer to use for specified type, if one found; null if not
* (and default key deserializer should be used)
*/
public abstract KeyDeserializer createKeyDeserializer(DeserializationContext ctxt
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.lang.reflect.Array;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.type.ArrayType;
import com.fasterxml.jackson.databind.util.ObjectBuffer;
/**
* Basic serializer that can serialize non-primitive arrays.
*/
@JacksonStdImpl
public class ObjectArrayDeserializer
extends ContainerDeserializerBase<Object[]>
implements ContextualDeserializer
{
private static final long serialVersionUID = 1L;
// // Configuration
/**
* Full generic type of the array being deserialized
*/
protected final ArrayType _arrayType;
/**
* Flag that indicates whether the component type is Object or not.
* Used for minor optimization when constructing result.
*/
protected final boolean _untyped;
/**
* Type of contained elements: needed for constructing actual
* result array
*/
protected final Class<?> _elementClass;
/**
* Element deserializer
*/
protected JsonDeserializer<Object> _elementDeserializer;
/**
* If element instances have polymorphic type information, this
* is the type deserializer that can handle it
*/
protected final TypeDeserializer _elementTypeDeserializer;
/**
* Specific override for this instance (from proper, or global per-type overrides)
* to indicate whether single value may be taken to mean an unwrapped one-element array
* or not. If null, left to global defaults.
*
* @since 2.7
*/
protected final Boolean _unwrapSingle;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
public ObjectArrayDeserializer(ArrayType arrayType,
JsonDeserializer<Object> elemDeser, TypeDeserializer elemTypeDeser)
{
super(arrayType);
_arrayType = arrayType;
_elementClass = arrayType.getContentType().getRawClass();
_untyped = (_elementClass == Object.class);
_elementDeserializer
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> = elemDeser;
_elementTypeDeserializer = elemTypeDeser;
_unwrapSingle = null;
}
protected ObjectArrayDeserializer(ObjectArrayDeserializer base,
JsonDeserializer<Object> elemDeser, TypeDeserializer elemTypeDeser,
Boolean unwrapSingle)
{
super(base._arrayType);
_arrayType = base._arrayType;
_elementClass = base._elementClass;
_untyped = base._untyped;
_elementDeserializer = elemDeser;
_elementTypeDeserializer = elemTypeDeser;
_unwrapSingle = unwrapSingle;
}
/**
* Overridable fluent-factory method used to create contextual instances
*/
public ObjectArrayDeserializer withDeserializer(TypeDeserializer elemTypeDeser,
JsonDeserializer<?> elemDeser)
{
return withResolved(elemTypeDeser, elemDeser, _unwrapSingle);
}
/**
* @since 2.7
*/
@SuppressWarnings("unchecked")
public ObjectArrayDeserializer withResolved(TypeDeserializer elemTypeDeser,
JsonDeserializer<?> elemDeser, Boolean unwrapSingle)
{
if ((unwrapSingle == _unwrapSingle)
&& (elemDeser == _elementDeserializer)
&& (elemTypeDeser == _elementTypeDeserializer)) {
return this;
}
return new ObjectArrayDeserializer(this,
(JsonDeserializer<Object>) elemDeser, elemTypeDeser, unwrapSingle);
}
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
JsonDeserializer<?> deser = _elementDeserializer;
Boolean unwrapSingle = findFormatFeature(ctxt, property, _arrayType.getRawClass(),
JsonFormat.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
// May have a content converter
deser = findConvertingContentDeserializer(ctxt, property, deser);
final JavaType vt = _arrayType.getContentType();
if (deser == null) {
deser = ctxt.findContextualValueDeserializer(vt, property);
} else { // if directly assigned, probably not yet contextual, so:
deser = ctxt.handleSecondaryContextualization(deser, property, vt);
}
TypeDeserializer elemTypeDeser = _elementTypeDeserializer;
if (elemTypeDeser != null) {
elemTypeDeser = elemTypeDeser
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>.forProperty(property);
}
return withResolved(elemTypeDeser, deser, unwrapSingle);
}
@Override // since 2.5
public boolean isCachable() {
// Important: do NOT cache if polymorphic values, or ones with custom deserializer
return (_elementDeserializer == null) && (_elementTypeDeserializer == null);
}
/*
/**********************************************************
/* ContainerDeserializerBase API
/**********************************************************
*/
@Override
public JavaType getContentType() {
return _arrayType.getContentType();
}
@Override
public JsonDeserializer<Object> getContentDeserializer() {
return _elementDeserializer;
}
/*
/**********************************************************
/* JsonDeserializer API
/**********************************************************
*/
@Override
public Object[] deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// Ok: must point to START_ARRAY (or equivalent)
if (!p.isExpectedStartArrayToken()) {
return handleNonArray(p, ctxt);
}
final ObjectBuffer buffer = ctxt.leaseObjectBuffer();
Object[] chunk = buffer.resetAndStart();
int ix = 0;
JsonToken t;
final TypeDeserializer typeDeser = _elementTypeDeserializer;
try {
while ((t = p.nextToken()) != JsonToken.END_ARRAY) {
// Note: must handle null explicitly here; value deserializers won't
Object value;
if (t == JsonToken.VALUE_NULL) {
value = _elementDeserializer.getNullValue(ctxt);
} else if (typeDeser == null) {
value = _elementDeserializer.deserialize(p, ctxt);
} else {
value = _elementDeserializer.deserializeWithType(p, ctxt, typeDeser);
}
if (ix >= chunk.length) {
chunk = buffer.appendCompletedChunk(chunk);
ix = 0;
}
chunk[ix++] = value;
}
} catch (Exception e) {
throw JsonMappingException.wrapWithPath(e, chunk, buffer.bufferedSize() + ix);
}
Object[] result;
if (_untyped) {
result = buffer.completeAndClearBuffer(chunk, ix);
} else {
result = buffer.completeAndClearBuffer(chunk, ix, _elementClass);
}
ctxt.returnObjectBuffer(buffer
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser;
import com.fasterxml.jackson.databind.*;
/**
* Add-on interface that {@link JsonDeserializer}s can implement to get a callback
* that can be used to create contextual (context-dependent) instances of
* deserializer to use for handling properties of supported type.
* This can be useful
* for deserializers that can be configured by annotations, or should otherwise
* have differing behavior depending on what kind of property is being deserialized.
*<p>
* Note that in cases where deserializer needs both contextualization and
* resolution -- that is, implements both this interface and {@link ResolvableDeserializer}
* -- resolution via {@link ResolvableDeserializer} occurs first, and contextual
* resolution (via this interface) later on.
*/
public interface ContextualDeserializer
{
/**
* Method called to see if a different (or differently configured) deserializer
* is needed to deserialize values of specified property.
* Note that instance that this method is called on is typically shared one and
* as a result method should <b>NOT</b> modify this instance but rather construct
* and return a new instance. This instance should only be returned as-is, in case
* it is already suitable for use.
*
* @param ctxt Deserialization context to access configuration, additional
* deserializers that may be needed by this deserializer
* @param property Method, field or constructor parameter that represents the property
* (and is used to assign deserialized value).
* Should be available; but there may be cases where caller can not provide it and
* null is passed instead (in which case impls usually pass 'this' deserializer as is)
*
* @return Deserializer to use for deserializing values of specified property;
* may be this instance or a new instance.
*
* @throws JsonMappingException
*/
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property)
throws JsonMappingException;
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>Unknown);
}
protected BeanDeserializer(BeanDeserializerBase src, NameTransformer unwrapper) {
super(src, unwrapper);
}
public BeanDeserializer(BeanDeserializerBase src, ObjectIdReader oir) {
super(src, oir);
}
public BeanDeserializer(BeanDeserializerBase src, Set<String> ignorableProps) {
super(src, ignorableProps);
}
public BeanDeserializer(BeanDeserializerBase src, BeanPropertyMap props) {
super(src, props);
}
@Override
public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper)
{
/* bit kludgy but we don't want to accidentally change type; sub-classes
* MUST override this method to support unwrapped properties...
*/
if (getClass() != BeanDeserializer.class) {
return this;
}
/* main thing really is to just enforce ignoring of unknown
* properties; since there may be multiple unwrapped values
* and properties for all may be interleaved...
*/
return new BeanDeserializer(this, unwrapper);
}
@Override
public BeanDeserializer withObjectIdReader(ObjectIdReader oir) {
return new BeanDeserializer(this, oir);
}
@Override
public BeanDeserializer withIgnorableProperties(Set<String> ignorableProps) {
return new BeanDeserializer(this, ignorableProps);
}
@Override
public BeanDeserializerBase withBeanProperties(BeanPropertyMap props) {
return new BeanDeserializer(this, props);
}
@Override
protected BeanDeserializerBase asArrayDeserializer() {
SettableBeanProperty[] props = _beanProperties.getPropertiesInInsertionOrder();
return new BeanAsArrayDeserializer(this, props);
}
/*
/**********************************************************
/* JsonDeserializer implementation
/**********************************************************
*/
/**
* Main deserialization method for bean-based objects (POJOs).
*/
@Override
public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException
{
// common case first
if (p.isExpectedStartObjectToken()) {
if (_vanillaProcessing) {
return vanillaDeserialize(p, ctxt, p.nextToken());
}
// 23-Sep-2015, tatu: This is wrong at some many levels, but for now... it is
// what it is, including "
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> return _properties.values().iterator();
}
public SettableBeanProperty findProperty(PropertyName propertyName) {
return _properties.get(propertyName.getSimpleName());
}
public boolean hasProperty(PropertyName propertyName) {
return findProperty(propertyName) != null;
}
public SettableBeanProperty removeProperty(PropertyName name) {
return _properties.remove(name.getSimpleName());
}
public SettableAnyProperty getAnySetter() {
return _anySetter;
}
public ValueInstantiator getValueInstantiator() {
return _valueInstantiator;
}
public List<ValueInjector> getInjectables() {
return _injectables;
}
public ObjectIdReader getObjectIdReader() {
return _objectIdReader;
}
public AnnotatedMethod getBuildMethod() {
return _buildMethod;
}
public JsonPOJOBuilder.Value getBuilderConfig() {
return _builderConfig;
}
/*
/**********************************************************
/* Build method(s)
/**********************************************************
*/
/**
* Method for constructing a {@link BeanDeserializer}, given all
* information collected.
*/
public JsonDeserializer<?> build()
{
Collection<SettableBeanProperty> props = _properties.values();
_fixAccess(props);
BeanPropertyMap propertyMap = BeanPropertyMap.construct(props,
_config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES));
propertyMap.assignIndexes();
// view processing must be enabled if:
// (a) fields are not included by default (when deserializing with view), OR
// (b) one of properties has view(s) to included in defined
boolean anyViews = !_config.isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION);
if (!anyViews) {
for (SettableBeanProperty prop : props) {
if (prop.hasViews()) {
anyViews = true;
break;
}
}
}
// one more thing: may need to create virtual ObjectId property:
if (_objectIdReader != null) {
/* 18-Nov-2012, tatu: May or may not have annotations for id property;
* but no easy access. But hard to see id property being optional,
* so let's consider required at this point.
*/
ObjectIdValueProperty prop = new ObjectId
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>ValueProperty(_objectIdReader, PropertyMetadata.STD_REQUIRED);
propertyMap = propertyMap.withProperty(prop);
}
return new BeanDeserializer(this,
_beanDesc, propertyMap, _backRefProperties, _ignorableProps, _ignoreAllUnknown,
anyViews);
}
/**
* Alternate build method used when we must be using some form of
* abstract resolution, usually by using addition Type Id
* ("polymorphic deserialization")
*
* @since 2.0
*/
public AbstractDeserializer buildAbstract() {
return new AbstractDeserializer(this, _beanDesc, _backRefProperties);
}
/**
* Method for constructing a specialized deserializer that uses
* additional external Builder object during data binding.
*/
public JsonDeserializer<?> buildBuilderBased(JavaType valueType,
String expBuildMethodName)
{
// First: validation; must have build method that returns compatible type
if (_buildMethod == null) {
// as per [databind#777], allow empty name
if (!expBuildMethodName.isEmpty()) {
throw new IllegalArgumentException(String.format(
"Builder class %s does not have build method (name: '%s')",
_beanDesc.getBeanClass().getName(),
expBuildMethodName));
}
} else {
// also: type of the method must be compatible
Class<?> rawBuildType = _buildMethod.getRawReturnType();
Class<?> rawValueType = valueType.getRawClass();
if ((rawBuildType != rawValueType)
&& !rawBuildType.isAssignableFrom(rawValueType)
&& !rawValueType.isAssignableFrom(rawBuildType)) {
throw new IllegalArgumentException("Build method '"+_buildMethod.getFullName()
+" has bad return type ("+rawBuildType.getName()
+"), not compatible with POJO type ("+valueType.getRawClass().getName()+")");
}
}
// And if so, we can try building the deserializer
Collection<SettableBeanProperty> props = _properties.values();
_fixAccess(props);
BeanPropertyMap propertyMap = BeanPropertyMap.construct(props,
_config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES));
propertyMap.assignIndexes();
boolean anyViews = !_config.isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION);
if (!any
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> */
protected final DeserializationConfig _config;
/**
* Blueprint instance of deserialization context; used for creating
* actual instance when needed.
*/
protected final DefaultDeserializationContext _context;
/**
* Factory used for constructing {@link JsonGenerator}s
*/
protected final JsonFactory _parserFactory;
/**
* Flag that indicates whether root values are expected to be unwrapped or not
*/
protected final boolean _unwrapRoot;
/**
* Filter to be consider for JsonParser.
* Default value to be null as filter not considered.
*/
private final TokenFilter _filter;
/*
/**********************************************************
/* Configuration that can be changed during building
/**********************************************************
*/
/**
* Declared type of value to instantiate during deserialization.
* Defines which deserializer to use; as well as base type of instance
* to construct if an updatable value is not configured to be used
* (subject to changes by embedded type information, for polymorphic
* types). If {@link #_valueToUpdate} is non-null, only used for
* locating deserializer.
*/
protected final JavaType _valueType;
/**
* We may pre-fetch deserializer as soon as {@link #_valueType}
* is known, and if so, reuse it afterwards.
* This allows avoiding further deserializer lookups and increases
* performance a bit on cases where readers are reused.
*
* @since 2.1
*/
protected final JsonDeserializer<Object> _rootDeserializer;
/**
* Instance to update with data binding; if any. If null,
* a new instance is created, if non-null, properties of
* this value object will be updated instead.
* Note that value can be of almost any type, except not
* {@link com.fasterxml.jackson.databind.type.ArrayType}; array
* types can not be modified because array size is immutable.
*/
protected final Object _valueToUpdate;
/**
* When using data format that uses a schema, schema is passed
* to parser.
*/
protected final FormatSchema _schema;
/**
* Values that can be injected during deserialization, if any.
*/
protected final InjectableValues _injectableValues;
/**
* Optional detector used for auto-detecting data format that byte-based
* input uses.
*
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS><p>
* NOTE: If defined non-null, <code>readValue()</code> methods that take
* {@link Reader} or {@link String} input <b>will fail with exception</b>,
* because format-detection only works on byte-sources. Also, if format
* can not be detect reliably (as per detector settings),
* a {@link JsonParseException} will be thrown).
*
* @since 2.1
*/
protected final DataFormatReaders _dataFormatReaders;
/*
/**********************************************************
/* Caching
/**********************************************************
*/
/**
* Root-level cached deserializers.
* Passed by {@link ObjectMapper}, shared with it.
*/
final protected ConcurrentHashMap<JavaType, JsonDeserializer<Object>> _rootDeserializers;
/*
/**********************************************************
/* Life-cycle, construction
/**********************************************************
*/
/**
* Constructor used by {@link ObjectMapper} for initial instantiation
*/
protected ObjectReader(ObjectMapper mapper, DeserializationConfig config) {
this(mapper, config, null, null, null, null);
}
/**
* Constructor called when a root deserializer should be fetched based
* on other configuration.
*/
protected ObjectReader(ObjectMapper mapper, DeserializationConfig config,
JavaType valueType, Object valueToUpdate,
FormatSchema schema, InjectableValues injectableValues)
{
_config = config;
_context = mapper._deserializationContext;
_rootDeserializers = mapper._rootDeserializers;
_parserFactory = mapper._jsonFactory;
_valueType = valueType;
_valueToUpdate = valueToUpdate;
if (valueToUpdate != null && valueType.isArrayType()) {
throw new IllegalArgumentException("Can not update an array value");
}
_schema = schema;
_injectableValues = injectableValues;
_unwrapRoot = config.useRootWrapping();
_rootDeserializer = _prefetchRootDeserializer(valueType);
_dataFormatReaders = null;
_filter = null;
}
/**
* Copy constructor used for building variations.
*/
protected ObjectReader(ObjectReader base, DeserializationConfig config,
JavaType valueType, JsonDeserializer<Object> rootDeser, Object valueToUpdate,
FormatSchema schema, InjectableValues injectableValues,
DataFormatReaders dataFormatReaders)
{
_
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> = base._valueType;
_rootDeserializer = base._rootDeserializer;
_valueToUpdate = base._valueToUpdate;
_schema = base._schema;
_injectableValues = base._injectableValues;
_unwrapRoot = base._unwrapRoot;
_dataFormatReaders = base._dataFormatReaders;
_filter = filter;
}
/**
* Method that will return version information stored in and read from jar
* that contains this class.
*/
@Override
public Version version() {
return com.fasterxml.jackson.databind.cfg.PackageVersion.VERSION;
}
/*
/**********************************************************
/* Methods sub-classes MUST override, used for constructing
/* reader instances, (re)configuring parser instances
/* Added in 2.5
/**********************************************************
*/
/**
* Overridable factory method called by various "withXxx()" methods
*
* @since 2.5
*/
protected ObjectReader _new(ObjectReader base, JsonFactory f) {
return new ObjectReader(base, f);
}
/**
* Overridable factory method called by various "withXxx()" methods
*
* @since 2.5
*/
protected ObjectReader _new(ObjectReader base, DeserializationConfig config) {
return new ObjectReader(base, config);
}
/**
* Overridable factory method called by various "withXxx()" methods
*
* @since 2.5
*/
protected ObjectReader _new(ObjectReader base, DeserializationConfig config,
JavaType valueType, JsonDeserializer<Object> rootDeser, Object valueToUpdate,
FormatSchema schema, InjectableValues injectableValues,
DataFormatReaders dataFormatReaders) {
return new ObjectReader(base, config, valueType, rootDeser, valueToUpdate,
schema, injectableValues, dataFormatReaders);
}
/**
* Factory method used to create {@link MappingIterator} instances;
* either default, or custom subtype.
*
* @since 2.5
*/
protected <T> MappingIterator<T> _newIterator(JsonParser p, DeserializationContext ctxt,
JsonDeserializer<?> deser, boolean parserManaged)
{
return new MappingIterator<T>(_valueType, p, ctxt,
deser, parserManaged, _valueToUpdate);
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>2.6
*/
public ObjectReader withoutRootName() {
return _with(_config.withRootName(PropertyName.NO_NAME));
}
/**
* Method for constructing a new instance with configuration that
* passes specified {@link FormatSchema} to {@link JsonParser} that
* is constructed for parsing content.
*<p>
* Note that the method does NOT change state of this reader, but
* rather construct and returns a newly configured instance.
*/
public ObjectReader with(FormatSchema schema)
{
if (_schema == schema) {
return this;
}
_verifySchemaType(schema);
return _new(this, _config, _valueType, _rootDeserializer, _valueToUpdate,
schema, _injectableValues, _dataFormatReaders);
}
/**
* Method for constructing a new reader instance that is configured
* to data bind into specified type.
*<p>
* Note that the method does NOT change state of this reader, but
* rather construct and returns a newly configured instance.
*
* @since 2.5
*/
public ObjectReader forType(JavaType valueType)
{
if (valueType != null && valueType.equals(_valueType)) {
return this;
}
JsonDeserializer<Object> rootDeser = _prefetchRootDeserializer(valueType);
// type is stored here, no need to make a copy of config
DataFormatReaders det = _dataFormatReaders;
if (det != null) {
det = det.withType(valueType);
}
return _new(this, _config, valueType, rootDeser,
_valueToUpdate, _schema, _injectableValues, det);
}
/**
* Method for constructing a new reader instance that is configured
* to data bind into specified type.
*<p>
* Note that the method does NOT change state of this reader, but
* rather construct and returns a newly configured instance.
*
* @since 2.5
*/
public ObjectReader forType(Class<?> valueType) {
return forType(_config.constructType(valueType));
}
/**
* Method for constructing a new reader instance that is configured
* to data bind into specified type.
*<p>
* Note that the method does NOT change state of this reader,
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> _detectBindAndReadValues(
_dataFormatReaders.findFormat(_inputStream(src)), true);
}
return _bindAndReadValues(_considerFilter(_parserFactory.createParser(src), true));
}
/**
* @since 2.8
*/
public <T> MappingIterator<T> readValues(DataInput src) throws IOException
{
if (_dataFormatReaders != null) {
_reportUndetectableSource(src);
}
return _bindAndReadValues(_considerFilter(_parserFactory.createParser(src), true));
}
/*
/**********************************************************
/* Implementation of rest of ObjectCodec methods
/**********************************************************
*/
@Override
public <T> T treeToValue(TreeNode n, Class<T> valueType) throws JsonProcessingException
{
try {
return readValue(treeAsTokens(n), valueType);
} catch (JsonProcessingException e) {
throw e;
} catch (IOException e) { // should not occur, no real i/o...
throw new IllegalArgumentException(e.getMessage(), e);
}
}
@Override
public void writeValue(JsonGenerator gen, Object value) throws IOException, JsonProcessingException {
throw new UnsupportedOperationException("Not implemented for ObjectReader");
}
/*
/**********************************************************
/* Helper methods, data-binding
/**********************************************************
*/
/**
* Actual implementation of value reading+binding operation.
*/
protected Object _bind(JsonParser p, Object valueToUpdate) throws IOException
{
/* First: may need to read the next token, to initialize state (either
* before first read from parser, or after previous token has been cleared)
*/
Object result;
final DeserializationContext ctxt = createDeserializationContext(p);
JsonToken t = _initForReading(ctxt, p);
if (t == JsonToken.VALUE_NULL) {
if (valueToUpdate == null) {
result = _findRootDeserializer(ctxt).getNullValue(ctxt);
} else {
result = valueToUpdate;
}
} else if (t == JsonToken.END_ARRAY || t == JsonToken.END_OBJECT) {
result = valueToUpdate;
} else { // pointing to event other than null
JsonDeserializer<Object> deser = _findRootDeserializer(ctxt);
if (_unwrapRoot) {
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
result = _unwrapAndDeserialize(p, ctxt, _valueType, deser);
} else {
if (valueToUpdate == null) {
result = deser.deserialize(p, ctxt);
} else {
deser.deserialize(p, ctxt, valueToUpdate);
result = valueToUpdate;
}
}
}
// Need to consume the token too
p.clearCurrentToken();
return result;
}
/**
* Consider filter when creating JsonParser.
*/
protected JsonParser _considerFilter(final JsonParser p, boolean multiValue) {
// 26-Mar-2016, tatu: Need to allow multiple-matches at least if we have
// have a multiple-value read (that is, "readValues()").
return ((_filter == null) || FilteringParserDelegate.class.isInstance(p))
? p : new FilteringParserDelegate(p, _filter, false, multiValue);
}
protected Object _bindAndClose(JsonParser p0) throws IOException
{
try (JsonParser p = p0) {
Object result;
DeserializationContext ctxt = createDeserializationContext(p);
JsonToken t = _initForReading(ctxt, p);
if (t == JsonToken.VALUE_NULL) {
if (_valueToUpdate == null) {
result = _findRootDeserializer(ctxt).getNullValue(ctxt);
} else {
result = _valueToUpdate;
}
} else if (t == JsonToken.END_ARRAY || t == JsonToken.END_OBJECT) {
result = _valueToUpdate;
} else {
JsonDeserializer<Object> deser = _findRootDeserializer(ctxt);
if (_unwrapRoot) {
result = _unwrapAndDeserialize(p, ctxt, _valueType, deser);
} else {
if (_valueToUpdate == null) {
result = deser.deserialize(p, ctxt);
} else {
deser.deserialize(p, ctxt, _valueToUpdate);
result = _valueToUpdate;
}
}
}
return result;
}
}
protected JsonNode _bindAndCloseAsTree(JsonParser p0) throws IOException {
try (JsonParser p = p0) {
return _bindAsTree(p);
}
}
protected JsonNode _bindAsTree(JsonParser p) throws IOException
{
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
JsonNode result;
DeserializationContext ctxt = createDeserializationContext(p);
JsonToken t = _initForReading(ctxt, p);
if (t == JsonToken.VALUE_NULL || t == JsonToken.END_ARRAY || t == JsonToken.END_OBJECT) {
result = NullNode.instance;
} else {
JsonDeserializer<Object> deser = _findTreeDeserializer(ctxt);
if (_unwrapRoot) {
result = (JsonNode) _unwrapAndDeserialize(p, ctxt, JSON_NODE_TYPE, deser);
} else {
result = (JsonNode) deser.deserialize(p, ctxt);
}
}
// Need to consume the token too
p.clearCurrentToken();
return result;
}
/**
* @since 2.1
*/
protected <T> MappingIterator<T> _bindAndReadValues(JsonParser p) throws IOException
{
DeserializationContext ctxt = createDeserializationContext(p);
_initForMultiRead(ctxt, p);
p.nextToken();
return _newIterator(p, ctxt, _findRootDeserializer(ctxt), true);
}
protected Object _unwrapAndDeserialize(JsonParser p, DeserializationContext ctxt,
JavaType rootType, JsonDeserializer<Object> deser) throws IOException
{
PropertyName expRootName = _config.findRootName(rootType);
// 12-Jun-2015, tatu: Should try to support namespaces etc but...
String expSimpleName = expRootName.getSimpleName();
if (p.getCurrentToken() != JsonToken.START_OBJECT) {
ctxt.reportWrongTokenException(p, JsonToken.START_OBJECT,
"Current token not START_OBJECT (needed to unwrap root name '%s'), but %s",
expSimpleName, p.getCurrentToken());
}
if (p.nextToken() != JsonToken.FIELD_NAME) {
ctxt.reportWrongTokenException(p, JsonToken.FIELD_NAME,
"Current token not FIELD_NAME (to contain expected root name '%s'), but %s",
expSimpleName, p.getCurrentToken());
}
String actualName = p.getCurrentName();
if (!expSimpleName.equals(actualName)) {
ctxt.reportMappingException("Root name '%s' does not match expected ('%s')
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> for type %s",
actualName, expSimpleName, rootType);
}
// ok, then move to value itself....
p.nextToken();
Object result;
if (_valueToUpdate == null) {
result = deser.deserialize(p, ctxt);
} else {
deser.deserialize(p, ctxt, _valueToUpdate);
result = _valueToUpdate;
}
// and last, verify that we now get matching END_OBJECT
if (p.nextToken() != JsonToken.END_OBJECT) {
ctxt.reportWrongTokenException(p, JsonToken.END_OBJECT,
"Current token not END_OBJECT (to match wrapper object with root name '%s'), but %s",
expSimpleName, p.getCurrentToken());
}
return result;
}
/*
/**********************************************************
/* Internal methods, format auto-detection
/**********************************************************
*/
@SuppressWarnings("resource")
protected Object _detectBindAndClose(byte[] src, int offset, int length) throws IOException
{
DataFormatReaders.Match match = _dataFormatReaders.findFormat(src, offset, length);
if (!match.hasMatch()) {
_reportUnkownFormat(_dataFormatReaders, match);
}
JsonParser p = match.createParserWithMatch();
return match.getReader()._bindAndClose(p);
}
@SuppressWarnings("resource")
protected Object _detectBindAndClose(DataFormatReaders.Match match, boolean forceClosing)
throws IOException
{
if (!match.hasMatch()) {
_reportUnkownFormat(_dataFormatReaders, match);
}
JsonParser p = match.createParserWithMatch();
// One more thing: we Own the input stream now; and while it's
// not super clean way to do it, we must ensure closure so:
if (forceClosing) {
p.enable(JsonParser.Feature.AUTO_CLOSE_SOURCE);
}
// important: use matching ObjectReader (may not be 'this')
return match.getReader()._bindAndClose(p);
}
@SuppressWarnings("resource")
protected <T> MappingIterator<T> _detectBindAndReadValues(DataFormatReaders.Match match, boolean forceClosing)
throws IOException, JsonProcessingException
{
if (!match.has
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>
return _context.createInstance(_config, p, _injectableValues);
}
protected void _reportUndetectableSource(Object src) throws JsonProcessingException
{
// 17-Aug-2015, tatu: Unfortunately, no parser/generator available so:
throw new JsonParseException(null, "Can not use source of type "
+src.getClass().getName()+" with format auto-detection: must be byte- not char-based");
}
protected InputStream _inputStream(URL src) throws IOException {
return src.openStream();
}
protected InputStream _inputStream(File f) throws IOException {
return new FileInputStream(f);
}
/*
/**********************************************************
/* Helper methods, locating deserializers etc
/**********************************************************
*/
/**
* Method called to locate deserializer for the passed root-level value.
*/
protected JsonDeserializer<Object> _findRootDeserializer(DeserializationContext ctxt)
throws JsonMappingException
{
if (_rootDeserializer != null) {
return _rootDeserializer;
}
// Sanity check: must have actual type...
JavaType t = _valueType;
if (t == null) {
ctxt.reportMappingException("No value type configured for ObjectReader");
}
// First: have we already seen it?
JsonDeserializer<Object> deser = _rootDeserializers.get(t);
if (deser != null) {
return deser;
}
// Nope: need to ask provider to resolve it
deser = ctxt.findRootValueDeserializer(t);
if (deser == null) { // can this happen?
ctxt.reportMappingException("Can not find a deserializer for type %s", t);
}
_rootDeserializers.put(t, deser);
return deser;
}
/**
* @since 2.6
*/
protected JsonDeserializer<Object> _findTreeDeserializer(DeserializationContext ctxt)
throws JsonMappingException
{
JsonDeserializer<Object> deser = _rootDeserializers.get(JSON_NODE_TYPE);
if (deser == null) {
// Nope: need to ask provider to resolve it
deser = ctxt.findRootValueDeserializer(JSON_NODE_TYPE);
if (deser == null) { // can this happen?
ctxt.reportMappingException("Can not find
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS> a deserializer for type %s",
JSON_NODE_TYPE);
}
_rootDeserializers.put(JSON_NODE_TYPE, deser);
}
return deser;
}
/**
* Method called to locate deserializer ahead of time, if permitted
* by configuration. Method also is NOT to throw an exception if
* access fails.
*/
protected JsonDeserializer<Object> _prefetchRootDeserializer(JavaType valueType)
{
if (valueType == null || !_config.isEnabled(DeserializationFeature.EAGER_DESERIALIZER_FETCH)) {
return null;
}
// already cached?
JsonDeserializer<Object> deser = _rootDeserializers.get(valueType);
if (deser == null) {
try {
// If not, need to resolve; for which we need a temporary context as well:
DeserializationContext ctxt = createDeserializationContext(null);
deser = ctxt.findRootValueDeserializer(valueType);
if (deser != null) {
_rootDeserializers.put(valueType, deser);
}
return deser;
} catch (JsonProcessingException e) {
// need to swallow?
}
}
return deser;
}
}
JacksonDatabind, 68
<FILEB>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser!= null) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
JsonDeserializer<Object> delegateDeser = _arrayDelegateDeserializer;
<CHANGEE>
<CHANGES>
if ((delegateDeser!= null) || ((delegateDeser = _delegateDeserializer)!= null)) {
<CHANGEE>
<CHANGES>
delegateDeser.deserialize(p, ctxt));
<CHANGEE>
<CHANGES>
<CHANGEE>
<CHANGES>
private final JsonDeserializer<Object> _delegateDeserializer() {
JsonDeserializer<Object> deser = _delegateDeserializer;
if (deser == null) {
deser = _arrayDelegateDeserializer;
}
return deser;
}
<CHANGEE>
<FILEE>
<FILEB>
* to parse and use as a reference.
*/
protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object id = _objectIdReader.readObjectReference(p, ctxt);
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
// do we have it resolved?
Object pojo = roid.resolve();
if (pojo == null) { // not yet; should wait...
throw new UnresolvedForwardReference(p,
"Could not resolve Object Id ["+id+"] (for "+_beanType+").",
p.getCurrentLocation(), roid);
}
return pojo;
}
protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
DeserializationContext ctxt) throws IOException
{
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
return _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p, ctxt));
<CHANGEE>
}
if (_propertyBasedCreator != null) {
return _deserializeUsingPropertyBased(p, ctxt);
}
// should only occur for abstract types...
if (_beanType.isAbstract()) {
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (need to add/enable type information?)");
}
return ctxt.handleMissingInstantiator(_beanType.getRawClass(), p,
"no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)");
}
protected abstract Object _deserializeUsingPropertyBased(final JsonParser p,
final DeserializationContext ctxt)
throws IOException, JsonProcessingException;
@SuppressWarnings("incomplete-switch")
public Object deserializeFromNumber(JsonParser p, DeserializationContext ctxt)
throws IOException
{
// First things first: id Object Id is used, most likely that's it
if (_objectIdReader != null) {
return deserializeFromObjectId(p, ctxt);
}
<CHANGES>
<CHANGEE>
switch (p.getNumberType()) {
case INT:
<CHANGES>
if (_delegateDeserializer != null) {
<CHANGEE>
if (!_valueInstantiator.canCreateFromInt()) {
Object bean = _valueInstantiator.createUsingDelegate(ctxt,
<CHANGES>
_delegateDeserializer.deserialize(p<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.BeanDeserializer;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.util.NameTransformer;
/**
* Deserializer that builds on basic {@link BeanDeserializer} but
* override some aspects like instance construction.
*/
public class ThrowableDeserializer
extends BeanDeserializer
{
private static final long serialVersionUID = 1L;
protected final static String PROP_NAME_MESSAGE = "message";
/*
/************************************************************
/* Construction
/************************************************************
*/
public ThrowableDeserializer(BeanDeserializer baseDeserializer) {
super(baseDeserializer);
// need to disable this, since we do post-processing
_vanillaProcessing = false;
}
/**
* Alternative constructor used when creating "unwrapping" deserializers
*/
protected ThrowableDeserializer(BeanDeserializer src, NameTransformer unwrapper) {
super(src, unwrapper);
}
@Override
public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper) {
if (getClass() != ThrowableDeserializer.class) {
return this;
}
/* main thing really is to just enforce ignoring of unknown
* properties; since there may be multiple unwrapped values
* and properties for all may be interleaved...
*/
return new ThrowableDeserializer(this, unwrapper);
}
/*
/************************************************************
/* Overridden methods
/************************************************************
*/
@Override
public Object deserializeFromObject(JsonParser p, DeserializationContext ctxt) throws IOException
{
// 30-Sep-2010, tatu: Need to allow use of @JsonCreator, so:
if (_propertyBasedCreator != null) { // proper @JsonCreator
return _deserializeUsingPropertyBased(p, ctxt);
}
if (_delegateDeserializer != null) {
return _valueInstantiator.createUsingDelegate(ctxt,
_delegateDeserializer.deserialize(p, ctxt));
}
if (_beanType.isAbstract()) { // for good measure, check this too
return ctxt.handleMissingInstantiator(handledType(), p,
"abstract type (